meriyah 5.0.0 → 6.0.1

package/src/lexer/identifier.ts

@@ -1,196 +0,0 @@
-import { ParserState, Context } from '../common';
-import { Token, descKeywordTable } from '../token';
-import { Chars } from '../chars';
-import { advanceChar, consumeMultiUnitCodePoint, fromCodePoint, toHex } from './common';
-import { CharTypes, CharFlags, isIdentifierPart, isIdentifierStart, isIdPart } from './charClassifier';
-import { report, reportScannerError, Errors } from '../errors';
-
-/**
- * Scans identifier
- *
- * @param parser  Parser object
- * @param context Context masks
- */
-export function scanIdentifier(parser: ParserState, context: Context, isValidAsKeyword: 0 | 1): Token {
-  while (isIdPart[advanceChar(parser)]);
-  parser.tokenValue = parser.source.slice(parser.tokenPos, parser.index);
-
-  return parser.currentChar !== Chars.Backslash && parser.currentChar <= 0x7e
-    ? descKeywordTable[parser.tokenValue] || Token.Identifier
-    : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
-}
-
-/**
- * Scans unicode identifier
- *
- * @param parser  Parser object
- * @param context Context masks
- */
-export function scanUnicodeIdentifier(parser: ParserState, context: Context): Token {
-  const cookedChar = scanIdentifierUnicodeEscape(parser);
-  if (!isIdentifierPart(cookedChar)) report(parser, Errors.InvalidUnicodeEscapeSequence);
-  parser.tokenValue = fromCodePoint(cookedChar);
-  return scanIdentifierSlowCase(parser, context, /* hasEscape */ 1, CharTypes[cookedChar] & CharFlags.KeywordCandidate);
-}
-
-/**
- * Scans identifier slow case
- *
- * @param parser  Parser object
- * @param context Context masks
- * @param hasEscape True if contains a unicode sequence
- * @param isValidAsKeyword
- */
-export function scanIdentifierSlowCase(
-  parser: ParserState,
-  context: Context,
-  hasEscape: 0 | 1,
-  isValidAsKeyword: number
-): Token {
-  let start = parser.index;
-
-  while (parser.index < parser.end) {
-    if (parser.currentChar === Chars.Backslash) {
-      parser.tokenValue += parser.source.slice(start, parser.index);
-      hasEscape = 1;
-      const code = scanIdentifierUnicodeEscape(parser);
-      if (!isIdentifierPart(code)) report(parser, Errors.InvalidUnicodeEscapeSequence);
-      isValidAsKeyword = isValidAsKeyword && CharTypes[code] & CharFlags.KeywordCandidate;
-      parser.tokenValue += fromCodePoint(code);
-      start = parser.index;
-    } else if (isIdentifierPart(parser.currentChar) || consumeMultiUnitCodePoint(parser, parser.currentChar)) {
-      advanceChar(parser);
-    } else {
-      break;
-    }
-  }
-
-  if (parser.index <= parser.end) {
-    parser.tokenValue += parser.source.slice(start, parser.index);
-  }
-
-  const { length } = parser.tokenValue;
-
-  if (isValidAsKeyword && length >= 2 && length <= 11) {
-    const token: Token | undefined = descKeywordTable[parser.tokenValue];
-    if (token === void 0) return Token.Identifier;
-    if (!hasEscape) return token;
-
-    if (token === Token.AwaitKeyword) {
-      // await is only reserved word in async functions or modules
-      if ((context & (Context.Module | Context.InAwaitContext)) === 0) {
-        return token;
-      }
-      return Token.EscapedReserved;
-    }
-
-    if (context & Context.Strict) {
-      if (token === Token.StaticKeyword) {
-        return Token.EscapedFutureReserved;
-      }
-      if ((token & Token.FutureReserved) === Token.FutureReserved) {
-        return Token.EscapedFutureReserved;
-      }
-      if ((token & Token.Reserved) === Token.Reserved) {
-        if (context & Context.AllowEscapedKeyword && (context & Context.InGlobal) === 0) {
-          return token;
-        } else {
-          return Token.EscapedReserved;
-        }
-      }
-      return Token.AnyIdentifier;
-    }
-    if (
-      context & Context.AllowEscapedKeyword &&
-      (context & Context.InGlobal) === 0 &&
-      (token & Token.Reserved) === Token.Reserved
-    )
-      return token;
-    if (token === Token.YieldKeyword) {
-      return context & Context.AllowEscapedKeyword
-        ? Token.AnyIdentifier
-        : context & Context.InYieldContext
-          ? Token.EscapedReserved
-          : token;
-    }
-
-    // async is not reserved; it can be used as a variable name
-    // or statement label without restriction
-    if (token === Token.AsyncKeyword) {
-      // Escaped "async" such as \u0061sync can only be identifier
-      // not as "async" keyword
-      return Token.AnyIdentifier;
-    }
-    if ((token & Token.FutureReserved) === Token.FutureReserved) {
-      return token;
-    }
-    return Token.EscapedReserved;
-  }
-  return Token.Identifier;
-}
-
-/**
- * Scans private name
- *
- * @param parser  Parser object
- */
-export function scanPrivateIdentifier(parser: ParserState): Token {
-  if (!isIdentifierStart(advanceChar(parser))) report(parser, Errors.MissingPrivateIdentifier);
-  return Token.PrivateField;
-}
-
-/**
- * Scans unicode identifier
- *
- * @param parser  Parser object
- */
-export function scanIdentifierUnicodeEscape(parser: ParserState): number {
-  // Check for Unicode escape of the form '\uXXXX'
-  // and return code point value if valid Unicode escape is found.
-  if (parser.source.charCodeAt(parser.index + 1) !== Chars.LowerU) {
-    report(parser, Errors.InvalidUnicodeEscapeSequence);
-  }
-  parser.currentChar = parser.source.charCodeAt((parser.index += 2));
-  return scanUnicodeEscape(parser);
-}
-
-/**
- * Scans unicode escape value
- *
- * @param parser  Parser object
- */
-export function scanUnicodeEscape(parser: ParserState): number {
-  // Accept both \uxxxx and \u{xxxxxx}
-  let codePoint = 0;
-  const char = parser.currentChar;
-  // First handle a delimited Unicode escape, e.g. \u{1F4A9}
-  if (char === Chars.LeftBrace) {
-    const begin = parser.index - 2;
-    while (CharTypes[advanceChar(parser)] & CharFlags.Hex) {
-      codePoint = (codePoint << 4) | toHex(parser.currentChar);
-      if (codePoint > Chars.NonBMPMax) reportScannerError(begin, parser.line, parser.index + 1, Errors.UnicodeOverflow);
-    }
-
-    // At least 4 characters have to be read
-    if ((parser.currentChar as number) !== Chars.RightBrace) {
-      reportScannerError(begin, parser.line, parser.index - 1, Errors.InvalidHexEscapeSequence);
-    }
-    advanceChar(parser); // consumes '}'
-    return codePoint;
-  }
-
-  if ((CharTypes[char] & CharFlags.Hex) === 0) report(parser, Errors.InvalidHexEscapeSequence); // first one is mandatory
-
-  const char2 = parser.source.charCodeAt(parser.index + 1);
-  if ((CharTypes[char2] & CharFlags.Hex) === 0) report(parser, Errors.InvalidHexEscapeSequence);
-  const char3 = parser.source.charCodeAt(parser.index + 2);
-  if ((CharTypes[char3] & CharFlags.Hex) === 0) report(parser, Errors.InvalidHexEscapeSequence);
-  const char4 = parser.source.charCodeAt(parser.index + 3);
-  if ((CharTypes[char4] & CharFlags.Hex) === 0) report(parser, Errors.InvalidHexEscapeSequence);
-
-  codePoint = (toHex(char) << 12) | (toHex(char2) << 8) | (toHex(char3) << 4) | toHex(char4);
-
-  parser.currentChar = parser.source.charCodeAt((parser.index += 4));
-
-  return codePoint;
-}

package/src/lexer/index.ts

@@ -1,32 +0,0 @@
-export { scanSingleToken, nextToken, TokenLookup } from './scan';
-export {
-  skipMultiLineComment,
-  skipSingleLineComment,
-  skipHashBang,
-  skipSingleHTMLComment,
-  CommentType
-} from './comments';
-export {
-  advanceChar,
-  consumeMultiUnitCodePoint,
-  isExoticECMAScriptWhitespace,
-  fromCodePoint,
-  toHex,
-  consumeLineFeed,
-  scanNewLine,
-  LexerState,
-  NumberKind,
-  convertTokenType
-} from './common';
-export { CharTypes, CharFlags, isIdentifierStart, isIdentifierPart } from './charClassifier';
-export {
-  scanIdentifier,
-  scanIdentifierSlowCase,
-  scanUnicodeIdentifier,
-  scanPrivateIdentifier,
-  scanUnicodeEscape
-} from './identifier';
-export { scanString } from './string';
-export { scanNumber } from './numeric';
-export { scanTemplate, scanTemplateTail } from './template';
-export { scanRegularExpression } from './regexp';

package/src/lexer/jsx.ts

@@ -1,127 +0,0 @@
-import { CharFlags, CharTypes } from './charClassifier';
-import { Chars } from '../chars';
-import { Token } from '../token';
-import { ParserState, Context } from '../common';
-import { report, Errors } from '../errors';
-import { advanceChar, LexerState, TokenLookup, scanSingleToken, scanNewLine, consumeLineFeed } from './';
-import { decodeHTMLStrict } from './decodeHTML';
-
-/**
- * Scans JSX attribute value
- *
- * @param parser The parser instance
- * @param context Context masks
- */
-export function scanJSXAttributeValue(parser: ParserState, context: Context): Token {
-  parser.startPos = parser.tokenPos = parser.index;
-  parser.startColumn = parser.colPos = parser.column;
-  parser.startLine = parser.linePos = parser.line;
-  parser.setToken(
-    CharTypes[parser.currentChar] & CharFlags.StringLiteral
-      ? scanJSXString(parser, context)
-      : scanSingleToken(parser, context, LexerState.None)
-  );
-  return parser.getToken();
-}
-
-/**
- * Scans JSX string
- *
- * @param parser The parser object
- */
-export function scanJSXString(parser: ParserState, context: Context): Token {
-  const quote = parser.currentChar;
-  let char = advanceChar(parser);
-  const start = parser.index;
-  while (char !== quote) {
-    if (parser.index >= parser.end) report(parser, Errors.UnterminatedString);
-    char = advanceChar(parser);
-  }
-
-  // check for unterminated string
-  if (char !== quote) report(parser, Errors.UnterminatedString);
-  parser.tokenValue = parser.source.slice(start, parser.index);
-  advanceChar(parser); // skip the quote
-  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
-  return Token.StringLiteral;
-}
-
-/**
- * Scans JSX token
- *
- * @param parser The parser object
- */
-export function scanJSXToken(parser: ParserState, context: Context): Token {
-  parser.startPos = parser.tokenPos = parser.index;
-  parser.startColumn = parser.colPos = parser.column;
-  parser.startLine = parser.linePos = parser.line;
-
-  if (parser.index >= parser.end) return parser.setToken(Token.EOF);
-
-  const token = TokenLookup[parser.source.charCodeAt(parser.index)];
-
-  switch (token) {
-    // '<'
-    case Token.LessThan: {
-      advanceChar(parser);
-      if (parser.currentChar === Chars.Slash) {
-        advanceChar(parser);
-        parser.setToken(Token.JSXClose);
-      } else {
-        parser.setToken(Token.LessThan);
-      }
-
-      break;
-    }
-    // '{'
-    case Token.LeftBrace: {
-      advanceChar(parser);
-      parser.setToken(Token.LeftBrace);
-      break;
-    }
-    default: {
-      let state = LexerState.None;
-
-      while (parser.index < parser.end) {
-        const type = CharTypes[parser.source.charCodeAt(parser.index)];
-
-        if (type & CharFlags.CarriageReturn) {
-          state |= LexerState.NewLine | LexerState.LastIsCR;
-          scanNewLine(parser);
-        } else if (type & CharFlags.LineFeed) {
-          consumeLineFeed(parser, state);
-          state = (state & ~LexerState.LastIsCR) | LexerState.NewLine;
-        } else {
-          advanceChar(parser);
-        }
-
-        if (CharTypes[parser.currentChar] & CharFlags.JSXToken) break;
-      }
-
-      const raw = parser.source.slice(parser.tokenPos, parser.index);
-      if (context & Context.OptionsRaw) parser.tokenRaw = raw;
-      parser.tokenValue = decodeHTMLStrict(raw);
-      parser.setToken(Token.JSXText);
-    }
-  }
-
-  return parser.getToken();
-}
-
-/**
- * Scans JSX identifier
- *
- * @param parser The parser instance
- */
-export function scanJSXIdentifier(parser: ParserState): Token {
-  if ((parser.getToken() & Token.IsIdentifier) === Token.IsIdentifier) {
-    const { index } = parser;
-    let char = parser.currentChar;
-    while (CharTypes[char] & (CharFlags.Hyphen | CharFlags.IdentifierPart)) {
-      char = advanceChar(parser);
-    }
-    parser.tokenValue += parser.source.slice(index, parser.index);
-  }
-  parser.setToken(Token.Identifier);
-  return parser.getToken();
-}

package/src/lexer/numeric.ts

@@ -1,259 +0,0 @@
-import { ParserState, Context, Flags } from '../common';
-import { Token } from '../token';
-import { advanceChar, toHex, NumberKind } from './common';
-import { CharTypes, CharFlags, isIdentifierStart } from './charClassifier';
-import { Chars } from '../chars';
-import { report, Errors, reportScannerError } from '../errors';
-
-/**
- * Scans numeric literal
- *
- * @param parser  Parser object
- * @param context Context masks
- * @param isFloat
- */
-export function scanNumber(parser: ParserState, context: Context, kind: NumberKind): Token {
-  // DecimalLiteral ::
-  //   DecimalIntegerLiteral . DecimalDigits_opt
-  //   . DecimalDigits
-  let char = parser.currentChar;
-  let value: any = 0;
-  let digit = 9;
-  let atStart = kind & NumberKind.Float ? 0 : 1;
-  let digits = 0;
-  let allowSeparator: 0 | 1 = 0;
-
-  if (kind & NumberKind.Float) {
-    value = '.' + scanDecimalDigitsOrSeparator(parser, char);
-    char = parser.currentChar;
-    // It is a Syntax Error if the MV is not an integer. (dot decimalDigits)
-    if (char === Chars.LowerN) report(parser, Errors.InvalidBigInt);
-  } else {
-    if (char === Chars.Zero) {
-      char = advanceChar(parser);
-
-      // Hex
-      if ((char | 32) === Chars.LowerX) {
-        kind = NumberKind.Hex | NumberKind.ValidBigIntKind;
-        char = advanceChar(parser); // skips 'X', 'x'
-        while (CharTypes[char] & (CharFlags.Hex | CharFlags.Underscore)) {
-          if (char === Chars.Underscore) {
-            if (!allowSeparator) report(parser, Errors.ContinuousNumericSeparator);
-            allowSeparator = 0;
-            char = advanceChar(parser);
-            continue;
-          }
-          allowSeparator = 1;
-          value = value * 0x10 + toHex(char);
-          digits++;
-          char = advanceChar(parser);
-        }
-
-        if (digits === 0 || !allowSeparator) {
-          report(parser, digits === 0 ? Errors.MissingHexDigits : Errors.TrailingNumericSeparator);
-        }
-        // Octal
-      } else if ((char | 32) === Chars.LowerO) {
-        kind = NumberKind.Octal | NumberKind.ValidBigIntKind;
-        char = advanceChar(parser); // skips 'X', 'x'
-        while (CharTypes[char] & (CharFlags.Octal | CharFlags.Underscore)) {
-          if (char === Chars.Underscore) {
-            if (!allowSeparator) {
-              report(parser, Errors.ContinuousNumericSeparator);
-            }
-            allowSeparator = 0;
-            char = advanceChar(parser);
-            continue;
-          }
-          allowSeparator = 1;
-          value = value * 8 + (char - Chars.Zero);
-          digits++;
-          char = advanceChar(parser);
-        }
-        if (digits === 0 || !allowSeparator) {
-          report(parser, digits === 0 ? Errors.Unexpected : Errors.TrailingNumericSeparator);
-        }
-      } else if ((char | 32) === Chars.LowerB) {
-        kind = NumberKind.Binary | NumberKind.ValidBigIntKind;
-        char = advanceChar(parser); // skips 'B', 'b'
-        while (CharTypes[char] & (CharFlags.Binary | CharFlags.Underscore)) {
-          if (char === Chars.Underscore) {
-            if (!allowSeparator) {
-              report(parser, Errors.ContinuousNumericSeparator);
-            }
-            allowSeparator = 0;
-            char = advanceChar(parser);
-            continue;
-          }
-          allowSeparator = 1;
-          value = value * 2 + (char - Chars.Zero);
-          digits++;
-          char = advanceChar(parser);
-        }
-        if (digits === 0 || !allowSeparator) {
-          report(parser, digits === 0 ? Errors.Unexpected : Errors.TrailingNumericSeparator);
-        }
-      } else if (CharTypes[char] & CharFlags.Octal) {
-        // Octal integer literals are not permitted in strict mode code
-        if (context & Context.Strict) report(parser, Errors.StrictOctalEscape);
-        kind = NumberKind.ImplicitOctal;
-        while (CharTypes[char] & CharFlags.Decimal) {
-          if (CharTypes[char] & CharFlags.ImplicitOctalDigits) {
-            kind = NumberKind.NonOctalDecimal;
-            atStart = 0;
-            break;
-          }
-          value = value * 8 + (char - Chars.Zero);
-          char = advanceChar(parser);
-        }
-      } else if (CharTypes[char] & CharFlags.ImplicitOctalDigits) {
-        if (context & Context.Strict) report(parser, Errors.StrictOctalEscape);
-        parser.flags |= Flags.Octals;
-        kind = NumberKind.NonOctalDecimal;
-      } else if (char === Chars.Underscore) {
-        report(parser, Errors.Unexpected);
-      }
-    }
-
-    // Parse decimal digits and allow trailing fractional part
-    if (kind & NumberKind.DecimalNumberKind) {
-      if (atStart) {
-        while (digit >= 0 && CharTypes[char] & (CharFlags.Decimal | CharFlags.Underscore)) {
-          if (char === Chars.Underscore) {
-            char = advanceChar(parser);
-            if (char === Chars.Underscore || kind & NumberKind.NonOctalDecimal) {
-              reportScannerError(
-                parser.index,
-                parser.line,
-                parser.index + 1 /* skips `_` */,
-                Errors.ContinuousNumericSeparator
-              );
-            }
-            allowSeparator = 1;
-            continue;
-          }
-          allowSeparator = 0;
-          value = 10 * value + (char - Chars.Zero);
-          char = advanceChar(parser);
-          --digit;
-        }
-
-        if (allowSeparator) {
-          reportScannerError(
-            parser.index,
-            parser.line,
-            parser.index + 1 /* skips `_` */,
-            Errors.TrailingNumericSeparator
-          );
-        }
-
-        if (digit >= 0 && !isIdentifierStart(char) && char !== Chars.Period) {
-          // Most numbers are pure decimal integers without fractional component
-          // or exponential notation.  Handle that with optimized code.
-          parser.tokenValue = value;
-          if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
-          return Token.NumericLiteral;
-        }
-      }
-
-      value += scanDecimalDigitsOrSeparator(parser, char);
-
-      char = parser.currentChar;
-
-      // Consume any decimal dot and fractional component.
-      if (char === Chars.Period) {
-        if (advanceChar(parser) === Chars.Underscore) report(parser, Errors.Unexpected);
-        kind = NumberKind.Float;
-        value += '.' + scanDecimalDigitsOrSeparator(parser, parser.currentChar);
-        char = parser.currentChar;
-      }
-    }
-  }
-  const end = parser.index;
-
-  let isBigInt: 0 | 1 = 0;
-
-  if (char === Chars.LowerN && kind & NumberKind.ValidBigIntKind) {
-    isBigInt = 1;
-    char = advanceChar(parser);
-  } else {
-    // Consume any exponential notation.
-    if ((char | 32) === Chars.LowerE) {
-      char = advanceChar(parser);
-
-      // '-', '+'
-      if (CharTypes[char] & CharFlags.Exponent) char = advanceChar(parser);
-
-      const { index } = parser;
-
-      // Exponential notation must contain at least one digit
-      if ((CharTypes[char] & CharFlags.Decimal) === 0) report(parser, Errors.MissingExponent);
-
-      // Consume exponential digits
-      value += parser.source.substring(end, index) + scanDecimalDigitsOrSeparator(parser, char);
-
-      char = parser.currentChar;
-    }
-  }
-
-  // The source character immediately following a numeric literal must
-  // not be an identifier start or a decimal digit
-  if ((parser.index < parser.end && CharTypes[char] & CharFlags.Decimal) || isIdentifierStart(char)) {
-    report(parser, Errors.IDStartAfterNumber);
-  }
-
-  if (isBigInt) {
-    parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
-    parser.tokenValue = BigInt(value);
-    return Token.BigIntLiteral;
-  }
-
-  parser.tokenValue =
-    kind & (NumberKind.ImplicitOctal | NumberKind.Binary | NumberKind.Hex | NumberKind.Octal)
-      ? value
-      : kind & NumberKind.NonOctalDecimal
-        ? parseFloat(parser.source.substring(parser.tokenPos, parser.index))
-        : +value;
-
-  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
-
-  return Token.NumericLiteral;
-}
-
-/**
- * Scans numeric literal and skip underscore '_' if it exist
- *
- * @param parser  Parser object
- * @param char Code point
- */
-export function scanDecimalDigitsOrSeparator(parser: ParserState, char: number): string {
-  let allowSeparator: 0 | 1 = 0;
-  let start = parser.index;
-  let ret = '';
-  while (CharTypes[char] & (CharFlags.Decimal | CharFlags.Underscore)) {
-    if (char === Chars.Underscore) {
-      const { index } = parser;
-      char = advanceChar(parser);
-      if (char === Chars.Underscore) {
-        reportScannerError(
-          parser.index,
-          parser.line,
-          parser.index + 1 /* skips `_` */,
-          Errors.ContinuousNumericSeparator
-        );
-      }
-      allowSeparator = 1;
-      ret += parser.source.substring(start, index);
-      start = parser.index;
-      continue;
-    }
-    allowSeparator = 0;
-    char = advanceChar(parser);
-  }
-
-  if (allowSeparator) {
-    reportScannerError(parser.index, parser.line, parser.index + 1 /* skips `_` */, Errors.TrailingNumericSeparator);
-  }
-
-  return ret + parser.source.substring(start, parser.index);
-}