@lithent/lithent-template-parser 0.1.0 → 0.1.1

package/src/docPipe/scan.ts

@@ -4,201 +4,214 @@ export interface TemplateMatch {
   snippet: string;
 }
 
-const DEFAULT_ALPHA_NUMERIC = new Set<number>();
+const identifierStart = (char: string): boolean => /[A-Za-z_$]/.test(char);
+const identifierPart = (char: string): boolean => /[\w$]/.test(char);
+const expressionKeywords = new Set([
+  'return',
+  'throw',
+  'yield',
+  'await',
+  'case',
+  'delete',
+  'void',
+  'typeof',
+  'new',
+  'in',
+  'instanceof',
+  'else',
+  'do',
+]);
 
-for (let code = 48; code <= 57; code++) {
-  DEFAULT_ALPHA_NUMERIC.add(code);
-}
-for (let code = 65; code <= 90; code++) {
-  DEFAULT_ALPHA_NUMERIC.add(code);
-}
-for (let code = 97; code <= 122; code++) {
-  DEFAULT_ALPHA_NUMERIC.add(code);
-}
-DEFAULT_ALPHA_NUMERIC.add(95); // _
-DEFAULT_ALPHA_NUMERIC.add(36); // $
-
-const isAlphaNumeric = (code: number): boolean => {
-  return DEFAULT_ALPHA_NUMERIC.has(code);
-};
-
-const shouldAttemptTemplate = (source: string, index: number): boolean => {
-  if (source[index] !== '<') {
-    return false;
-  }
-
-  const next = source.charCodeAt(index + 1);
-  if (Number.isNaN(next)) {
-    return false;
-  }
-
-  // Allow fragments <>, closing </, comments <!-, normal tags <a
-  const isValidNext =
-    next === 47 || // /
-    next === 62 || // >
-    next === 33 || // ! (e.g. <!-- -->)
-    isAlphaNumeric(next);
-  if (!isValidNext) {
-    return false;
+const skipQuoted = (source: string, index: number, quote: string): number => {
+  let i = index + 1;
+  while (i < source.length) {
+    if (source[i] === '\\') i += 2;
+    else if (source[i++] === quote) return i;
   }
+  return source.length;
+};
 
-  // Ensure previous meaningful char is not part of an identifier (e.g. a<b)
-  let i = index - 1;
-  while (i >= 0) {
-    const code = source.charCodeAt(i);
-    if (code === 32 || code === 9 || code === 10 || code === 13) {
-      i--;
-      continue;
-    }
-    if (isAlphaNumeric(code)) {
-      // Identifier characters => likely relational operator (e.g. a<b)
-      return false;
-    }
-    break;
-  }
+const skipLineComment = (source: string, index: number): number => {
+  let i = index;
+  while (i < source.length && !/[\r\n]/.test(source[i])) i++;
+  return i;
+};
 
-  return true;
+const skipBlockComment = (source: string, index: number): number => {
+  const end = source.indexOf('*/', index + 2);
+  return end === -1 ? source.length : end + 2;
 };
 
-const skipQuoted = (source: string, index: number, quote: string): number => {
+const skipRegex = (source: string, index: number): number => {
   let i = index + 1;
+  let inClass = false;
   while (i < source.length) {
-    const ch = source[i];
-    if (ch === '\\') {
-      i += 2;
-      continue;
-    }
-    if (ch === quote) {
-      return i + 1;
-    }
-    i++;
+    const char = source[i++];
+    if (char === '\\') i++;
+    else if (char === '[') inClass = true;
+    else if (char === ']') inClass = false;
+    else if (char === '/' && !inClass) {
+      while (i < source.length && /[a-z]/i.test(source[i])) i++;
+      return i;
+    } else if (char === '\n' || char === '\r') return i;
   }
-  return source.length;
+  return i;
 };
 
 const skipTemplateLiteral = (source: string, index: number): number => {
   let i = index + 1;
   while (i < source.length) {
-    const ch = source[i];
-    if (ch === '\\') {
-      i += 2;
-      continue;
-    }
-    if (ch === '`') {
-      return i + 1;
-    }
-    if (ch === '$' && source[i + 1] === '{') {
-      const result = skipJsExpression(source, i + 2);
-      if (result == null) {
-        return source.length;
-      }
-      i = result;
-      continue;
-    }
-    i++;
-  }
-  return source.length;
-};
-
-const skipLineComment = (source: string, index: number): number => {
-  let i = index;
-  while (i < source.length && source[i] !== '\n') {
-    i++;
+    if (source[i] === '\\') i += 2;
+    else if (source[i] === '`') return i + 1;
+    else if (source[i] === '$' && source[i + 1] === '{') {
+      const end = skipJsExpression(source, i + 2);
+      if (end === null) return source.length;
+      i = end;
+    } else i++;
   }
   return i;
 };
 
-const skipBlockComment = (source: string, index: number): number => {
-  const end = source.indexOf('*/', index);
-  return end === -1 ? source.length : end + 2;
-};
+interface JsContext {
+  controlParentheses: boolean[];
+  controlKeyword: boolean;
+  blocks: boolean[];
+  previous: string;
+  statementStart: boolean;
+}
+
+const createContext = (statementStart: boolean): JsContext => ({
+  controlParentheses: [],
+  controlKeyword: false,
+  blocks: [],
+  previous: '',
+  statementStart,
+});
+
+interface JsToken {
+  end: number;
+  expressionAllowed: boolean;
+}
 
-const skipHtmlComment = (source: string, index: number): number => {
-  const end = source.indexOf('-->', index);
-  return end === -1 ? source.length : end + 3;
+/** Advance one JS token without interpreting strings, comments, or regexes as markup. */
+const nextJsToken = (
+  source: string,
+  index: number,
+  expressionAllowed: boolean,
+  context: JsContext
+): JsToken => {
+  const char = source[index];
+  if (/\s/.test(char)) return { end: index + 1, expressionAllowed };
+  if (char === '/' && source[index + 1] === '/') {
+    return { end: skipLineComment(source, index + 2), expressionAllowed };
+  }
+  if (char === '/' && source[index + 1] === '*') {
+    return { end: skipBlockComment(source, index), expressionAllowed };
+  }
+  if (char === '"' || char === "'") {
+    context.previous = 'literal';
+    context.statementStart = false;
+    return { end: skipQuoted(source, index, char), expressionAllowed: false };
+  }
+  if (char === '`')
+    return {
+      end: skipTemplateLiteral(source, index),
+      expressionAllowed: false,
+    };
+  if (char === '/' && expressionAllowed)
+    return { end: skipRegex(source, index), expressionAllowed: false };
+  if (identifierStart(char)) {
+    let end = index + 1;
+    while (end < source.length && identifierPart(source[end])) end++;
+    const word = source.slice(index, end);
+    context.controlKeyword = /^(if|while|for|with|switch|catch)$/.test(word);
+    context.previous = word;
+    context.statementStart = /^(else|do|try|finally)$/.test(word);
+    return { end, expressionAllowed: expressionKeywords.has(word) };
+  }
+  if (/[0-9]/.test(char)) {
+    let end = index + 1;
+    while (end < source.length && /[\w.]/.test(source[end])) end++;
+    return { end, expressionAllowed: false };
+  }
+  if (char === '(') {
+    context.controlParentheses.push(context.controlKeyword);
+    context.controlKeyword = false;
+    context.previous = char;
+    context.statementStart = false;
+    return { end: index + 1, expressionAllowed: true };
+  }
+  if (char === ')') {
+    const control = context.controlParentheses.pop() ?? false;
+    context.previous = char;
+    context.statementStart = control;
+    return { end: index + 1, expressionAllowed: control };
+  }
+  if (char === '{') {
+    const block =
+      context.statementStart ||
+      context.previous === ')' ||
+      context.previous === '>';
+    context.blocks.push(block);
+    context.previous = char;
+    context.statementStart = block;
+    return { end: index + 1, expressionAllowed: true };
+  }
+  if (char === '}') {
+    const block = context.blocks.pop() ?? false;
+    context.previous = char;
+    context.statementStart = block;
+    return { end: index + 1, expressionAllowed: block };
+  }
+  context.previous = char;
+  context.statementStart = char === ';';
+  if ((char === '+' || char === '-') && source[index + 1] === char) {
+    return { end: index + 2, expressionAllowed };
+  }
+  return { end: index + 1, expressionAllowed: !/[)\]}.]/.test(char) };
 };
 
-const skipJsExpression = (source: string, index: number): number | null => {
+/** Return the offset after a matching }, starting immediately after the opening {. */
+export const skipJsExpression = (
+  source: string,
+  index: number
+): number | null => {
   let depth = 1;
   let i = index;
+  let expressionAllowed = true;
+  const context = createContext(false);
   while (i < source.length) {
-    const ch = source[i];
-    if (ch === '\\') {
-      i += 2;
-      continue;
-    }
-    if (ch === "'" || ch === '"') {
-      i = skipQuoted(source, i, ch);
-      continue;
-    }
-    if (ch === '`') {
-      i = skipTemplateLiteral(source, i);
-      continue;
-    }
-    if (ch === '/' && source[i + 1] === '*') {
-      i = skipBlockComment(source, i + 2);
-      continue;
-    }
-    if (ch === '/' && source[i + 1] === '/') {
-      i = skipLineComment(source, i + 2);
-      continue;
-    }
-    if (ch === '{') {
-      depth++;
-      i++;
-      continue;
-    }
-    if (ch === '}') {
-      depth--;
-      i++;
-      if (depth === 0) {
-        return i;
+    const char = source[i];
+    if (char === '<' && expressionAllowed) {
+      const match = extractTemplate(source, i);
+      if (match) {
+        i = match.end;
+        expressionAllowed = false;
+        context.previous = 'template';
+        context.statementStart = false;
+        continue;
       }
-      continue;
     }
-    i++;
+    if (char === '{') depth++;
+    else if (char === '}' && --depth === 0) return i + 1;
+    const token = nextJsToken(source, i, expressionAllowed, context);
+    i = token.end;
+    expressionAllowed = token.expressionAllowed;
   }
   return null;
 };
 
-interface SkipTagResult {
-  position: number;
-  selfClosing: boolean;
-}
-
-const skipTag = (
-  source: string,
-  index: number,
-  closing: boolean
-): SkipTagResult | null => {
+const skipTag = (source: string, index: number): number | null => {
   let i = index;
   while (i < source.length) {
-    const ch = source[i];
-    if (ch === "'" || ch === '"') {
-      i = skipQuoted(source, i, ch);
-      continue;
-    }
-    if (ch === '{') {
-      const result = skipJsExpression(source, i + 1);
-      if (result == null) {
-        return null;
-      }
-      i = result;
-      continue;
-    }
-    if (ch === '/' && source[i + 1] === '*') {
-      i = skipBlockComment(source, i + 2);
-      continue;
-    }
-    if (ch === '/' && source[i + 1] === '/') {
-      i = skipLineComment(source, i + 2);
-      continue;
-    }
-    if (ch === '>') {
-      const selfClosing = !closing && source[i - 1] === '/';
-      return { position: i + 1, selfClosing };
-    }
-    i++;
+    const char = source[i];
+    if (char === '"' || char === "'") i = skipQuoted(source, i, char);
+    else if (char === '{') {
+      const end = skipJsExpression(source, i + 1);
+      if (end === null) return null;
+      i = end;
+    } else if (char === '>') return i + 1;
+    else i++;
   }
   return null;
 };
@@ -207,112 +220,62 @@ const extractTemplate = (
   source: string,
   start: number
 ): TemplateMatch | null => {
-  const len = source.length;
+  if (source[start] !== '<' || !/[A-Za-z_$>!]/.test(source[start + 1] ?? ''))
+    return null;
   let pos = start;
   let depth = 0;
-
-  while (pos < len) {
-    const ch = source[pos];
-
-    if (ch === '/' && source[pos + 1] === '*') {
-      pos = skipBlockComment(source, pos + 2);
-      continue;
-    }
-    if (ch === '/' && source[pos + 1] === '/') {
-      pos = skipLineComment(source, pos + 2);
+  while (pos < source.length) {
+    if (source.startsWith('<!--', pos)) {
+      const end = source.indexOf('-->', pos + 4);
+      if (end === -1) return null;
+      pos = end + 3;
       continue;
     }
-    if (ch === '{') {
-      const result = skipJsExpression(source, pos + 1);
-      if (result != null) {
-        pos = result;
+    if (source[pos] === '{') {
+      const end = skipJsExpression(source, pos + 1);
+      if (end !== null) {
+        pos = end;
         continue;
       }
+      // Still extract a malformed template when possible so compile can diagnose it.
     }
-    if (ch === '<') {
-      if (source.startsWith('<!--', pos)) {
-        pos = skipHtmlComment(source, pos + 4);
-        continue;
-      }
-
-      if (source[pos + 1] === '/') {
-        depth--;
-        const res = skipTag(source, pos + 2, true);
-        if (!res) {
-          return null;
-        }
-        pos = res.position;
-        if (depth === 0) {
-          return {
-            start,
-            end: pos,
-            snippet: source.slice(start, pos),
-          };
-        }
-        continue;
-      } else {
-        depth++;
-        const res = skipTag(source, pos + 1, false);
-        if (!res) {
-          return null;
-        }
-        pos = res.position;
-        if (res.selfClosing) {
-          depth--;
-          if (depth === 0) {
-            return {
-              start,
-              end: pos,
-              snippet: source.slice(start, pos),
-            };
-          }
-        }
-        continue;
-      }
+    if (source[pos] === '<') {
+      const closing = source[pos + 1] === '/';
+      const end = skipTag(source, pos + (closing ? 2 : 1));
+      if (end === null) return null;
+      depth += closing ? -1 : 1;
+      if (!closing && source[end - 2] === '/') depth--;
+      pos = end;
+      if (depth === 0)
+        return { start, end: pos, snippet: source.slice(start, pos) };
+      continue;
     }
-
+    // Template text is not JavaScript: quotes and // or /* have no special meaning here.
     pos++;
   }
-
   return null;
 };
 
 export const scanTemplates = (code: string): TemplateMatch[] => {
   const matches: TemplateMatch[] = [];
-  const len = code.length;
   let index = 0;
-
-  while (index < len) {
-    const ch = code[index];
-
-    if (ch === "'" || ch === '"') {
-      index = skipQuoted(code, index, ch);
-      continue;
-    }
-    if (ch === '`') {
-      index = skipTemplateLiteral(code, index);
-      continue;
-    }
-    if (ch === '/' && code[index + 1] === '*') {
-      index = skipBlockComment(code, index + 2);
-      continue;
-    }
-    if (ch === '/' && code[index + 1] === '/') {
-      index = skipLineComment(code, index + 2);
-      continue;
-    }
-
-    if (ch === '<' && shouldAttemptTemplate(code, index)) {
+  let expressionAllowed = true;
+  const context = createContext(true);
+  while (index < code.length) {
+    if (code[index] === '<' && expressionAllowed) {
       const match = extractTemplate(code, index);
       if (match) {
         matches.push(match);
         index = match.end;
+        expressionAllowed = false;
+        context.previous = 'template';
+        context.statementStart = false;
         continue;
       }
     }
-
-    index++;
+    const token = nextJsToken(code, index, expressionAllowed, context);
+    index = token.end;
+    expressionAllowed = token.expressionAllowed;
   }
-
   return matches;
 };