meriyah 5.0.0 → 6.0.0

package/src/lexer/string.ts

@@ -1,242 +0,0 @@
-import { ParserState, Context, Flags } from '../common';
-import { Token } from '../token';
-import { Chars } from '../chars';
-import { report, Errors } from '../errors';
-import { toHex, advanceChar, fromCodePoint } from './common';
-import { CharTypes, CharFlags } from './charClassifier';
-// Intentionally negative
-export const enum Escape {
-  Empty = -1,
-  StrictOctal = -2,
-  EightOrNine = -3,
-  InvalidHex = -4,
-  OutOfRange = -5
-}
-
-/**
- * Scan a string token.
- */
-export function scanString(parser: ParserState, context: Context, quote: number): Token {
-  const { index: start } = parser;
-
-  let ret: string | void = '';
-  let char = advanceChar(parser);
-  let marker = parser.index; // Consumes the quote
-
-  while ((CharTypes[char] & CharFlags.LineTerminator) === 0) {
-    if (char === quote) {
-      ret += parser.source.slice(marker, parser.index);
-      advanceChar(parser); // skip closing quote
-      if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(start, parser.index);
-      parser.tokenValue = ret;
-      return Token.StringLiteral;
-    }
-
-    if ((char & 8) === 8 && char === Chars.Backslash) {
-      ret += parser.source.slice(marker, parser.index);
-      char = advanceChar(parser);
-
-      if (char < 0x7f || char === Chars.LineSeparator || char === Chars.ParagraphSeparator) {
-        const code = parseEscape(parser, context, char);
-        if (code >= 0) ret += fromCodePoint(code);
-        else handleStringError(parser, code as Escape, /* isTemplate */ 0);
-      } else {
-        ret += fromCodePoint(char);
-      }
-      marker = parser.index + 1;
-    }
-
-    if (parser.index >= parser.end) report(parser, Errors.UnterminatedString);
-
-    char = advanceChar(parser);
-  }
-
-  report(parser, Errors.UnterminatedString);
-}
-
-// TODO! Use table lookup
-
-export function parseEscape(parser: ParserState, context: Context, first: number): number {
-  switch (first) {
-    // https://tc39.github.io/ecma262/#prod-SingleEscapeCharacter
-    // one of ' " \ b f n r t v
-    case Chars.LowerB:
-      return Chars.Backspace;
-    case Chars.LowerF:
-      return Chars.FormFeed;
-    case Chars.LowerR:
-      return Chars.CarriageReturn;
-    case Chars.LowerN:
-      return Chars.LineFeed;
-    case Chars.LowerT:
-      return Chars.Tab;
-    case Chars.LowerV:
-      return Chars.VerticalTab;
-
-    // Line continuations
-    case Chars.CarriageReturn: {
-      if (parser.index < parser.end) {
-        const nextChar = parser.source.charCodeAt(parser.index + 1);
-        if (nextChar === Chars.LineFeed) {
-          parser.index = parser.index + 1;
-          parser.currentChar = nextChar;
-        }
-      }
-    }
-    // falls through
-
-    case Chars.LineFeed:
-    case Chars.LineSeparator:
-    case Chars.ParagraphSeparator:
-      parser.column = -1;
-      parser.line++;
-      return Escape.Empty;
-
-    // Null character, octals
-    case Chars.Zero:
-    case Chars.One:
-    case Chars.Two:
-    case Chars.Three: {
-      let code = first - Chars.Zero;
-      let index = parser.index + 1;
-      let column = parser.column + 1;
-
-      if (index < parser.end) {
-        const next = parser.source.charCodeAt(index);
-
-        if ((CharTypes[next] & CharFlags.Octal) === 0) {
-          // Verify that it's `\0` if we're in strict mode.
-          if ((code !== 0 || CharTypes[next] & CharFlags.ImplicitOctalDigits) && context & Context.Strict)
-            return Escape.StrictOctal;
-        } else if (context & Context.Strict) {
-          return Escape.StrictOctal;
-        } else {
-          parser.currentChar = next;
-          code = (code << 3) | (next - Chars.Zero);
-          index++;
-          column++;
-          if (index < parser.end) {
-            const next = parser.source.charCodeAt(index);
-
-            if (CharTypes[next] & CharFlags.Octal) {
-              parser.currentChar = next;
-              code = (code << 3) | (next - Chars.Zero);
-              index++;
-              column++;
-            }
-          }
-
-          parser.flags |= Flags.Octals;
-
-          parser.index = index - 1;
-          parser.column = column - 1;
-        }
-      }
-
-      return code;
-    }
-
-    case Chars.Four:
-    case Chars.Five:
-    case Chars.Six:
-    case Chars.Seven: {
-      if (context & Context.Strict) return Escape.StrictOctal;
-
-      let code = first - Chars.Zero;
-      const index = parser.index + 1;
-      const column = parser.column + 1;
-
-      if (index < parser.end) {
-        const next = parser.source.charCodeAt(index);
-
-        if (CharTypes[next] & CharFlags.Octal) {
-          code = (code << 3) | (next - Chars.Zero);
-          parser.currentChar = next;
-          parser.index = index;
-          parser.column = column;
-        }
-      }
-
-      parser.flags |= Flags.Octals;
-
-      return code;
-    }
-
-    // HexEscapeSequence
-    // \x HexDigit HexDigit
-    case Chars.LowerX: {
-      const ch1 = advanceChar(parser);
-      if ((CharTypes[ch1] & CharFlags.Hex) === 0) return Escape.InvalidHex;
-      const hi = toHex(ch1);
-      const ch2 = advanceChar(parser);
-      if ((CharTypes[ch2] & CharFlags.Hex) === 0) return Escape.InvalidHex;
-      const lo = toHex(ch2);
-
-      return (hi << 4) | lo;
-    }
-
-    // UnicodeEscapeSequence
-    // \u HexDigit HexDigit HexDigit HexDigit
-    // \u { HexDigit HexDigit HexDigit ... }
-    case Chars.LowerU: {
-      const ch = advanceChar(parser);
-
-      if (parser.currentChar === Chars.LeftBrace) {
-        let code = 0;
-        while ((CharTypes[advanceChar(parser)] & CharFlags.Hex) !== 0) {
-          code = (code << 4) | toHex(parser.currentChar);
-          if (code > Chars.NonBMPMax) return Escape.OutOfRange;
-        }
-
-        if (parser.currentChar < 1 || (parser.currentChar as number) !== Chars.RightBrace) {
-          return Escape.InvalidHex;
-        }
-        return code;
-      } else {
-        if ((CharTypes[ch] & CharFlags.Hex) === 0) return Escape.InvalidHex; // first one is mandatory
-        const ch2 = parser.source.charCodeAt(parser.index + 1);
-        if ((CharTypes[ch2] & CharFlags.Hex) === 0) return Escape.InvalidHex;
-        const ch3 = parser.source.charCodeAt(parser.index + 2);
-        if ((CharTypes[ch3] & CharFlags.Hex) === 0) return Escape.InvalidHex;
-        const ch4 = parser.source.charCodeAt(parser.index + 3);
-        if ((CharTypes[ch4] & CharFlags.Hex) === 0) return Escape.InvalidHex;
-
-        parser.index += 3;
-        parser.column += 3;
-
-        parser.currentChar = parser.source.charCodeAt(parser.index);
-
-        return (toHex(ch) << 12) | (toHex(ch2) << 8) | (toHex(ch3) << 4) | toHex(ch4);
-      }
-    }
-
-    // `8`, `9` (invalid escapes)
-    case Chars.Eight:
-    case Chars.Nine:
-      if ((context & Context.OptionsWebCompat) === 0) return Escape.EightOrNine;
-    // fallthrough
-    default:
-      return first;
-  }
-}
-
-export function handleStringError(state: ParserState, code: Escape, isTemplate: 0 | 1): void {
-  switch (code) {
-    case Escape.Empty:
-      return;
-
-    case Escape.StrictOctal:
-      report(state, isTemplate ? Errors.TemplateOctalLiteral : Errors.StrictOctalEscape);
-
-    case Escape.EightOrNine:
-      report(state, Errors.InvalidEightAndNine);
-
-    case Escape.InvalidHex:
-      report(state, Errors.InvalidHexEscapeSequence);
-
-    case Escape.OutOfRange:
-      report(state, Errors.UnicodeOverflow);
-
-    // No default
-  }
-}

package/src/lexer/template.ts

@@ -1,108 +0,0 @@
-import { ParserState, Context } from '../common';
-import { Token } from '../token';
-import { Chars } from '../chars';
-import { advanceChar, fromCodePoint } from './common';
-import { parseEscape, Escape, handleStringError } from './string';
-import { report, Errors } from '../errors';
-
-/**
- * Scan a template section. It can start either from the quote or closing brace.
- */
-export function scanTemplate(parser: ParserState, context: Context): Token {
-  const { index: start } = parser;
-  let token: Token = Token.TemplateSpan;
-  let ret: string | void = '';
-
-  let char = advanceChar(parser);
-
-  while (char !== Chars.Backtick) {
-    if (char === Chars.Dollar && parser.source.charCodeAt(parser.index + 1) === Chars.LeftBrace) {
-      advanceChar(parser); // Skip: '}'
-      token = Token.TemplateContinuation;
-      break;
-    } else if ((char & 8) === 8 && char === Chars.Backslash) {
-      char = advanceChar(parser);
-      if (char > 0x7e) {
-        ret += fromCodePoint(char);
-      } else {
-        const code = parseEscape(parser, context | Context.Strict, char);
-        if (code >= 0) {
-          ret += fromCodePoint(code);
-        } else if (code !== Escape.Empty && context & Context.TaggedTemplate) {
-          ret = undefined;
-          char = scanBadTemplate(parser, char);
-          if (char < 0) token = Token.TemplateContinuation;
-          break;
-        } else {
-          handleStringError(parser, code as Escape, /* isTemplate */ 1);
-        }
-      }
-    } else {
-      if (
-        parser.index < parser.end &&
-        char === Chars.CarriageReturn &&
-        parser.source.charCodeAt(parser.index) === Chars.LineFeed
-      ) {
-        ret += fromCodePoint(char);
-        parser.currentChar = parser.source.charCodeAt(++parser.index);
-      }
-
-      if (((char & 83) < 3 && char === Chars.LineFeed) || (char ^ Chars.LineSeparator) <= 1) {
-        parser.column = -1;
-        parser.line++;
-      }
-      ret += fromCodePoint(char);
-    }
-    if (parser.index >= parser.end) report(parser, Errors.UnterminatedTemplate);
-    char = advanceChar(parser);
-  }
-
-  advanceChar(parser); // Consume the quote or opening brace
-  parser.tokenValue = ret;
-
-  parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === Token.TemplateSpan ? 1 : 2));
-
-  return token;
-}
-
-/**
- * Scans looser template segment
- *
- * @param parser Parser state
- * @param ch Code point
- */
-function scanBadTemplate(parser: ParserState, ch: number): number {
-  while (ch !== Chars.Backtick) {
-    switch (ch) {
-      case Chars.Dollar: {
-        const index = parser.index + 1;
-        if (index < parser.end && parser.source.charCodeAt(index) === Chars.LeftBrace) {
-          parser.index = index;
-          parser.column++;
-          return -ch;
-        }
-        break;
-      }
-      case Chars.LineFeed:
-      case Chars.LineSeparator:
-      case Chars.ParagraphSeparator:
-        parser.column = -1;
-        parser.line++;
-      // falls through
-
-      default:
-      // do nothing
-    }
-    if (parser.index >= parser.end) report(parser, Errors.UnterminatedTemplate);
-    ch = advanceChar(parser);
-  }
-
-  return ch;
-}
-
-export function scanTemplateTail(parser: ParserState, context: Context): Token {
-  if (parser.index >= parser.end) report(parser, Errors.Unexpected);
-  parser.index--;
-  parser.column--;
-  return scanTemplate(parser, context);
-}

package/src/meriyah.ts

@@ -1,28 +0,0 @@
-import { Context } from './common';
-import { parseSource, Options } from './parser';
-import * as ESTree from './estree';
-// Current version
-import { version } from '../package.json';
-
-/**
- * Parse a script, optionally with various options.
- */
-export function parseScript(source: string, options?: Options): ESTree.Program {
-  return parseSource(source, options, Context.None);
-}
-
-/**
- * Parse a module, optionally with various options.
- */
-export function parseModule(source: string, options?: Options): ESTree.Program {
-  return parseSource(source, options, Context.Strict | Context.Module);
-}
-
-/**
- * Parse a module or a script, optionally with various options.
- */
-export function parse(source: string, options?: Options): ESTree.Program {
-  return parseSource(source, options, Context.None);
-}
-
-export { Options, ESTree, version };