Use accessible indentation (#2253)

1 files changed, 211 insertions, 211 deletions

diff --git a/packages/astro-parser/src/parse/read/expression.ts b/packages/astro-parser/src/parse/read/expression.ts
index b4647ab06..5d4b05c99 100644
--- a/packages/astro-parser/src/parse/read/expression.ts
+++ b/packages/astro-parser/src/parse/read/expression.ts
@@ -3,252 +3,252 @@ import { Parser } from '../index.js';
 import parseAstro from '../index.js';
 
 interface ParseState {
-  source: string;
-  start: number;
-  index: number;
-  curlyCount: number;
-  bracketCount: number;
-  root: Expression;
-  parser: Parser;
+	source: string;
+	start: number;
+	index: number;
+	curlyCount: number;
+	bracketCount: number;
+	root: Expression;
+	parser: Parser;
 }
 
 function peek_char(state: ParseState) {
-  return state.source[state.index];
+	return state.source[state.index];
 }
 
 function peek_nonwhitespace(state: ParseState) {
-  let index = state.index;
-  do {
-    let char = state.source[index];
-    if (!/\s/.test(char)) {
-      return char;
-    }
-    index++;
-  } while (index < state.source.length);
+	let index = state.index;
+	do {
+		let char = state.source[index];
+		if (!/\s/.test(char)) {
+			return char;
+		}
+		index++;
+	} while (index < state.source.length);
 }
 
 function next_char(state: ParseState) {
-  return state.source[state.index++];
+	return state.source[state.index++];
 }
 
 function in_bounds(state: ParseState) {
-  return state.index < state.source.length;
+	return state.index < state.source.length;
 }
 
 function consume_string(state: ParseState, stringChar: string) {
-  let inEscape;
-  do {
-    const char = next_char(state);
-
-    if (inEscape) {
-      inEscape = false;
-    } else if (char === '\\') {
-      inEscape = true;
-    } else if (char === stringChar) {
-      break;
-    }
-  } while (in_bounds(state));
+	let inEscape;
+	do {
+		const char = next_char(state);
+
+		if (inEscape) {
+			inEscape = false;
+		} else if (char === '\\') {
+			inEscape = true;
+		} else if (char === stringChar) {
+			break;
+		}
+	} while (in_bounds(state));
 }
 
 function consume_multiline_comment(state: ParseState) {
-  do {
-    const char = next_char(state);
+	do {
+		const char = next_char(state);
 
-    if (char === '*' && peek_char(state) === '/') {
-      break;
-    }
-  } while (in_bounds(state));
+		if (char === '*' && peek_char(state) === '/') {
+			break;
+		}
+	} while (in_bounds(state));
 }
 
 function consume_line_comment(state: ParseState) {
-  do {
-    const char = next_char(state);
-    if (char === '\n') {
-      break;
-    }
-  } while (in_bounds(state));
+	do {
+		const char = next_char(state);
+		if (char === '\n') {
+			break;
+		}
+	} while (in_bounds(state));
 }
 
 const voidElements = new Set(['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
 
 function consume_tag(state: ParseState) {
-  const start = state.index - 1;
-  let tagName = '';
-  let inTag = false;
-  let inStart = true;
-  let selfClosed = false;
-  let inClose = false;
-
-  let bracketIndex = 1;
-  do {
-    const char = next_char(state);
-
-    switch (char) {
-      case "'":
-      case '"':
-      case '`': {
-        consume_string(state, char);
-        break;
-      }
-      case '<': {
-        inTag = false;
-        tagName = '';
-
-        if (peek_nonwhitespace(state) === '/') {
-          inClose = true;
-          bracketIndex--;
-        } else {
-          inStart = true;
-          bracketIndex++;
-        }
-        break;
-      }
-      case '>': {
-        // An arrow function, probably
-        if (!inStart && !inClose) {
-          break;
-        }
-
-        bracketIndex--;
-
-        const addExpectedBrackets =
-          // Void elements don't need a closing
-          !voidElements.has(tagName.toLowerCase()) &&
-          // Self-closing don't need a closing
-          !selfClosed &&
-          // If we're in a start tag, we expect to find 2 more brackets
-          !inClose;
-
-        if (addExpectedBrackets) {
-          bracketIndex += 2;
-        }
-
-        inTag = false;
-        selfClosed = false;
-        inStart = false;
-        inClose = false;
-        break;
-      }
-      case ' ': {
-        inTag = true;
-        break;
-      }
-      case '/': {
-        if (inStart) {
-          selfClosed = true;
-        }
-        break;
-      }
-      default: {
-        if (!inTag) {
-          tagName += char;
-        }
-        break;
-      }
-    }
-
-    // Unclosed tags
-    if (state.curlyCount <= 0) {
-      break;
-    }
-
-    if (bracketIndex === 0) {
-      break;
-    }
-  } while (in_bounds(state));
-
-  const source = state.source.substring(start, state.index);
-
-  const ast = parseAstro(source);
-  state.parser.feature_flags |= ast.meta.features;
-  const fragment = ast.html;
-
-  return fragment;
+	const start = state.index - 1;
+	let tagName = '';
+	let inTag = false;
+	let inStart = true;
+	let selfClosed = false;
+	let inClose = false;
+
+	let bracketIndex = 1;
+	do {
+		const char = next_char(state);
+
+		switch (char) {
+			case "'":
+			case '"':
+			case '`': {
+				consume_string(state, char);
+				break;
+			}
+			case '<': {
+				inTag = false;
+				tagName = '';
+
+				if (peek_nonwhitespace(state) === '/') {
+					inClose = true;
+					bracketIndex--;
+				} else {
+					inStart = true;
+					bracketIndex++;
+				}
+				break;
+			}
+			case '>': {
+				// An arrow function, probably
+				if (!inStart && !inClose) {
+					break;
+				}
+
+				bracketIndex--;
+
+				const addExpectedBrackets =
+					// Void elements don't need a closing
+					!voidElements.has(tagName.toLowerCase()) &&
+					// Self-closing don't need a closing
+					!selfClosed &&
+					// If we're in a start tag, we expect to find 2 more brackets
+					!inClose;
+
+				if (addExpectedBrackets) {
+					bracketIndex += 2;
+				}
+
+				inTag = false;
+				selfClosed = false;
+				inStart = false;
+				inClose = false;
+				break;
+			}
+			case ' ': {
+				inTag = true;
+				break;
+			}
+			case '/': {
+				if (inStart) {
+					selfClosed = true;
+				}
+				break;
+			}
+			default: {
+				if (!inTag) {
+					tagName += char;
+				}
+				break;
+			}
+		}
+
+		// Unclosed tags
+		if (state.curlyCount <= 0) {
+			break;
+		}
+
+		if (bracketIndex === 0) {
+			break;
+		}
+	} while (in_bounds(state));
+
+	const source = state.source.substring(start, state.index);
+
+	const ast = parseAstro(source);
+	state.parser.feature_flags |= ast.meta.features;
+	const fragment = ast.html;
+
+	return fragment;
 }
 
 function consume_expression(parser: Parser, source: string, start: number): Expression {
-  const expr: Expression = {
-    type: 'Expression',
-    start,
-    end: Number.NaN,
-    codeChunks: [],
-    children: [],
-  };
-
-  let codeStart: number = start;
-
-  const state: ParseState = {
-    source,
-    start,
-    index: start,
-    curlyCount: 1,
-    bracketCount: 0,
-    root: expr,
-    parser,
-  };
-
-  do {
-    const char = next_char(state);
-
-    switch (char) {
-      case '{': {
-        state.curlyCount++;
-        break;
-      }
-      case '}': {
-        state.curlyCount--;
-        break;
-      }
-      case '<': {
-        const chunk = source.substring(codeStart, state.index - 1);
-        expr.codeChunks.push(chunk);
-        const tag = consume_tag(state);
-        expr.children.push(tag);
-        codeStart = state.index;
-        break;
-      }
-      case "'":
-      case '"':
-      case '`': {
-        consume_string(state, char);
-        break;
-      }
-      case '/': {
-        switch (peek_char(state)) {
-          case '/': {
-            consume_line_comment(state);
-            break;
-          }
-          case '*': {
-            consume_multiline_comment(state);
-            break;
-          }
-        }
-      }
-    }
-  } while (in_bounds(state) && state.curlyCount > 0);
-
-  expr.end = state.index - 1;
-
-  if (expr.children.length || !expr.codeChunks.length) {
-    expr.codeChunks.push(source.substring(codeStart, expr.end));
-  }
-
-  return expr;
+	const expr: Expression = {
+		type: 'Expression',
+		start,
+		end: Number.NaN,
+		codeChunks: [],
+		children: [],
+	};
+
+	let codeStart: number = start;
+
+	const state: ParseState = {
+		source,
+		start,
+		index: start,
+		curlyCount: 1,
+		bracketCount: 0,
+		root: expr,
+		parser,
+	};
+
+	do {
+		const char = next_char(state);
+
+		switch (char) {
+			case '{': {
+				state.curlyCount++;
+				break;
+			}
+			case '}': {
+				state.curlyCount--;
+				break;
+			}
+			case '<': {
+				const chunk = source.substring(codeStart, state.index - 1);
+				expr.codeChunks.push(chunk);
+				const tag = consume_tag(state);
+				expr.children.push(tag);
+				codeStart = state.index;
+				break;
+			}
+			case "'":
+			case '"':
+			case '`': {
+				consume_string(state, char);
+				break;
+			}
+			case '/': {
+				switch (peek_char(state)) {
+					case '/': {
+						consume_line_comment(state);
+						break;
+					}
+					case '*': {
+						consume_multiline_comment(state);
+						break;
+					}
+				}
+			}
+		}
+	} while (in_bounds(state) && state.curlyCount > 0);
+
+	expr.end = state.index - 1;
+
+	if (expr.children.length || !expr.codeChunks.length) {
+		expr.codeChunks.push(source.substring(codeStart, expr.end));
+	}
+
+	return expr;
 }
 
 export const parse_expression_at = (parser: Parser, source: string, index: number): Expression => {
-  const expression = consume_expression(parser, source, index);
+	const expression = consume_expression(parser, source, index);
 
-  return expression;
+	return expression;
 };
 
 export default function read_expression(parser: Parser) {
-  try {
-    const expression = parse_expression_at(parser, parser.template, parser.index);
-    parser.index = expression.end;
-    return expression;
-  } catch (err) {
-    parser.acorn_error(err);
-  }
+	try {
+		const expression = parse_expression_at(parser, parser.template, parser.index);
+		parser.index = expression.end;
+		return expression;
+	} catch (err) {
+		parser.acorn_error(err);
+	}
 }