meriyah 5.0.0 → 6.0.0

package/src/common.ts

@@ -1,834 +0,0 @@
-import { Token, KeywordDescTable } from './token';
-import { Errors, report } from './errors';
-import { Node, Comment, Decorator, SourceLocation } from './estree';
-import { nextToken } from './lexer/scan';
-
-/**
- * The core context, passed around everywhere as a simple immutable bit set
- */
-export const enum Context {
-  None = 0,
-  OptionsNext = 1 << 0,
-  OptionsRanges = 1 << 1,
-  OptionsLoc = 1 << 2,
-  OptionsDirectives = 1 << 3,
-  OptionsJSX = 1 << 4,
-  OptionsGlobalReturn = 1 << 5,
-  OptionsLexical = 1 << 6,
-  OptionsPreserveParens = 1 << 7,
-  OptionsWebCompat = 1 << 8,
-  OptionsRaw = 1 << 9,
-  Strict = 1 << 10,
-  Module = 1 << 11, // Current code should be parsed as a module body
-  InSwitch = 1 << 12,
-  InGlobal = 1 << 13,
-  InClass = 1 << 14,
-  AllowRegExp = 1 << 15,
-  TaggedTemplate = 1 << 16,
-  InIteration = 1 << 17,
-  SuperProperty = 1 << 18,
-  SuperCall = 1 << 19,
-  InYieldContext = 1 << 20,
-  InAwaitContext = 1 << 21,
-  InArgumentList = 1 << 22,
-  InConstructor = 1 << 23,
-  InMethod = 1 << 24,
-  AllowNewTarget = 1 << 25,
-  DisallowIn = 1 << 26,
-  AllowEscapedKeyword = 1 << 27,
-  OptionsUniqueKeyInPattern = 1 << 28
-}
-
-/**
- * Masks to track the property kind
- */
-export const enum PropertyKind {
-  None = 0,
-  Method = 1 << 0,
-  Computed = 1 << 1,
-  Shorthand = 1 << 2,
-  Generator = 1 << 3,
-  Async = 1 << 4,
-  Static = 1 << 5,
-  Constructor = 1 << 6,
-  ClassField = 1 << 7,
-  Getter = 1 << 8,
-  Setter = 1 << 9,
-  Extends = 1 << 10,
-  Literal = 1 << 11,
-  PrivateField = 1 << 12,
-  GetSet = Getter | Setter
-}
-
-/**
- * Masks to track the binding kind
- */
-export const enum BindingKind {
-  None = 0,
-  ArgumentList = 1 << 0,
-  Empty = 1 << 1,
-  Variable = 1 << 2,
-  Let = 1 << 3,
-  Const = 1 << 4,
-  Class = 1 << 5,
-  FunctionLexical = 1 << 6,
-  FunctionStatement = 1 << 7,
-  CatchPattern = 1 << 8,
-  CatchIdentifier = 1 << 9,
-  CatchIdentifierOrPattern = CatchIdentifier | CatchPattern,
-  LexicalOrFunction = Variable | FunctionLexical,
-  LexicalBinding = Let | Const | FunctionLexical | FunctionStatement | Class
-}
-
-/**
- * The masks to track where something begins. E.g. statements, declarations or arrows.
- */
-export const enum Origin {
-  None = 0,
-  Statement = 1 << 0,
-  BlockStatement = 1 << 1,
-  TopLevel = 1 << 2,
-  Declaration = 1 << 3,
-  Arrow = 1 << 4,
-  ForStatement = 1 << 5,
-  Export = 1 << 6
-}
-
-/**
- * Masks to track the assignment kind
- */
-export const enum AssignmentKind {
-  None = 0,
-  Assignable = 1 << 0,
-  CannotAssign = 1 << 1
-}
-
-/**
- * Masks to track the destructuring kind
- */
-export const enum DestructuringKind {
-  None = 0,
-  HasToDestruct = 1 << 3,
-  // "Cannot" rather than "can" so that this flag can be ORed together across
-  // multiple characters.
-  CannotDestruct = 1 << 4,
-  // Only destructible if assignable
-  Assignable = 1 << 5,
-  // `__proto__` is a special case and only valid to parse if destructible
-  SeenProto = 1 << 6,
-  Await = 1 << 7,
-  Yield = 1 << 8
-}
-
-/**
- * The mutable parser flags, in case any flags need passed by reference.
- */
-export const enum Flags {
-  None = 0,
-  NewLine = 1 << 0,
-  HasConstructor = 1 << 5,
-  Octals = 1 << 6,
-  SimpleParameterList = 1 << 7,
-  HasStrictReserved = 1 << 8,
-  StrictEvalArguments = 1 << 9,
-  DisallowCall = 1 << 10,
-  HasOptionalChaining = 1 << 11
-}
-
-export const enum HoistedClassFlags {
-  None,
-  Hoisted = 1 << 0,
-  Export = 1 << 1
-}
-
-export const enum HoistedFunctionFlags {
-  None,
-  Hoisted = 1 << 0,
-  Export = 1 << 1
-}
-
-/**
- * Scope kinds
- */
-export const enum ScopeKind {
-  None = 0,
-  ForStatement = 1 << 0,
-  Block = 1 << 1,
-  CatchStatement = 1 << 2,
-  SwitchStatement = 1 << 3,
-  ArgList = 1 << 4,
-  TryStatement = 1 << 5,
-  CatchBlock = 1 << 6,
-  FunctionBody = 1 << 7,
-  FunctionRoot = 1 << 8,
-  FunctionParams = 1 << 9,
-  ArrowParams = 1 << 10,
-  CatchIdentifier = 1 << 11
-}
-
-/**
- * The type of the `onComment` option.
- */
-export type OnComment =
-  | void
-  | Comment[]
-  | ((type: string, value: string, start: number, end: number, loc: SourceLocation) => any);
-
-/**
- * The type of the `onInsertedSemicolon` option.
- */
-export type OnInsertedSemicolon = void | ((pos: number) => any);
-
-/**
- * The type of the `onToken` option.
- */
-export type OnToken = void | Token[] | ((token: string, start: number, end: number, loc: SourceLocation) => any);
-
-/**
- * Lexical scope interface
- */
-export interface ScopeState {
-  parent: ScopeState | undefined;
-  type: ScopeKind;
-  scopeError?: ScopeError | null;
-}
-
-/** Scope error interface */
-export interface ScopeError {
-  type: Errors;
-  params: string[];
-  index: number;
-  line: number;
-  column: number;
-}
-
-/**
- * The parser interface.
- */
-export interface ParserState {
-  source: string;
-  flags: Flags;
-  index: number;
-  line: number;
-  column: number;
-  tokenPos: number;
-  startPos: number;
-  startColumn: number;
-  startLine: number;
-  colPos: number;
-  linePos: number;
-  end: number;
-  getToken(): Token;
-  setToken(token: Token): Token;
-  onComment: any;
-  onInsertedSemicolon: any;
-  onToken: any;
-  tokenValue: any;
-  tokenRaw: string;
-  tokenRegExp: void | {
-    pattern: string;
-    flags: string;
-  };
-  sourceFile: string | void;
-  assignable: AssignmentKind | DestructuringKind;
-  destructible: AssignmentKind | DestructuringKind;
-  currentChar: number;
-  exportedNames: any;
-  exportedBindings: any;
-  leadingDecorators: Decorator[];
-}
-
-/**
- * Check for automatic semicolon insertion according to the rules
- * given in `ECMA-262, section 11.9`.
- *
- * @param parser Parser object
- * @param context Context masks
- */
-
-export function matchOrInsertSemicolon(parser: ParserState, context: Context): void {
-  if ((parser.flags & Flags.NewLine) === 0 && (parser.getToken() & Token.IsAutoSemicolon) !== Token.IsAutoSemicolon) {
-    report(parser, Errors.UnexpectedToken, KeywordDescTable[parser.getToken() & Token.Type]);
-  }
-
-  if (!consumeOpt(parser, context, Token.Semicolon)) {
-    // Automatic semicolon insertion has occurred
-    parser.onInsertedSemicolon?.(parser.startPos);
-  }
-}
-
-export function isValidStrictMode(parser: ParserState, index: number, tokenPos: number, tokenValue: string): 0 | 1 {
-  if (index - tokenPos < 13 && tokenValue === 'use strict') {
-    if ((parser.getToken() & Token.IsAutoSemicolon) === Token.IsAutoSemicolon || parser.flags & Flags.NewLine) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-/**
- * Consumes the current token if the current token kind is
- * the specified `kind` and returns `0`. Otherwise returns `1`.
- *
- * @param parser Parser state
- * @param context Context masks
- * @param token The type of token to consume
- */
-export function optionalBit(parser: ParserState, context: Context, t: Token): 0 | 1 {
-  if (parser.getToken() !== t) return 0;
-  nextToken(parser, context);
-  return 1;
-}
-
-/** Consumes the current token if the current token kind is
- * the specified `kind` and returns `true`. Otherwise returns
- * `false`.
- *
- * @param parser Parser state
- * @param context Context masks
- * @param token The type of token to consume
- */
-export function consumeOpt(parser: ParserState, context: Context, t: Token): boolean {
-  if (parser.getToken() !== t) return false;
-  nextToken(parser, context);
-  return true;
-}
-
-/**
- * Consumes the current token. If the current token kind is not
- * the specified `kind`, an error will be reported.
- *
- * @param parser Parser state
- * @param context Context masks
- * @param t The type of token to consume
- */
-export function consume(parser: ParserState, context: Context, t: Token): void {
-  if (parser.getToken() !== t) report(parser, Errors.ExpectedToken, KeywordDescTable[t & Token.Type]);
-  nextToken(parser, context);
-}
-
-/**
- * Transforms a `LeftHandSideExpression` into a `AssignmentPattern` if possible,
- * otherwise it returns the original tree.
- *
- * @param parser Parser state
- * @param {*} node
- */
-export function reinterpretToPattern(state: ParserState, node: any): void {
-  switch (node.type) {
-    case 'ArrayExpression': {
-      node.type = 'ArrayPattern';
-      const { elements } = node;
-      for (let i = 0, n = elements.length; i < n; ++i) {
-        const element = elements[i];
-        if (element) reinterpretToPattern(state, element);
-      }
-      return;
-    }
-    case 'ObjectExpression': {
-      node.type = 'ObjectPattern';
-      const { properties } = node;
-      for (let i = 0, n = properties.length; i < n; ++i) {
-        reinterpretToPattern(state, properties[i]);
-      }
-      return;
-    }
-    case 'AssignmentExpression':
-      node.type = 'AssignmentPattern';
-      if (node.operator !== '=') report(state, Errors.InvalidDestructuringTarget);
-      delete node.operator;
-      reinterpretToPattern(state, node.left);
-      return;
-    case 'Property':
-      reinterpretToPattern(state, node.value);
-      return;
-    case 'SpreadElement':
-      node.type = 'RestElement';
-      reinterpretToPattern(state, node.argument);
-    // No default
-  }
-}
-
-/**
- * Validates binding identifier
- *
- * @param parser Parser state
- * @param context Context masks
- * @param type Binding type
- * @param token Token
- */
-
-export function validateBindingIdentifier(
-  parser: ParserState,
-  context: Context,
-  kind: BindingKind,
-  t: Token,
-  skipEvalArgCheck: 0 | 1
-): void {
-  if (context & Context.Strict) {
-    if ((t & Token.FutureReserved) === Token.FutureReserved) {
-      report(parser, Errors.UnexpectedStrictReserved);
-    }
-
-    if (!skipEvalArgCheck && (t & Token.IsEvalOrArguments) === Token.IsEvalOrArguments) {
-      report(parser, Errors.StrictEvalArguments);
-    }
-  }
-
-  if ((t & Token.Reserved) === Token.Reserved) {
-    report(parser, Errors.KeywordNotId);
-  }
-
-  // The BoundNames of LexicalDeclaration and ForDeclaration must not
-  // contain 'let'. (CatchParameter is the only lexical binding form
-  // without this restriction.)
-  if (kind & (BindingKind.Let | BindingKind.Const) && t === Token.LetKeyword) {
-    report(parser, Errors.InvalidLetConstBinding);
-  }
-
-  if (context & (Context.InAwaitContext | Context.Module) && t === Token.AwaitKeyword) {
-    report(parser, Errors.AwaitOutsideAsync);
-  }
-
-  if (context & (Context.InYieldContext | Context.Strict) && t === Token.YieldKeyword) {
-    report(parser, Errors.DisallowedInContext, 'yield');
-  }
-}
-
-export function validateFunctionName(parser: ParserState, context: Context, t: Token): void {
-  if (context & Context.Strict) {
-    if ((t & Token.FutureReserved) === Token.FutureReserved) {
-      report(parser, Errors.UnexpectedStrictReserved);
-    }
-
-    if ((t & Token.IsEvalOrArguments) === Token.IsEvalOrArguments) {
-      report(parser, Errors.StrictEvalArguments);
-    }
-
-    if (t === Token.EscapedFutureReserved) {
-      report(parser, Errors.InvalidEscapedKeyword);
-    }
-
-    if (t === Token.EscapedReserved) {
-      report(parser, Errors.InvalidEscapedKeyword);
-    }
-  }
-
-  if ((t & Token.Reserved) === Token.Reserved) {
-    report(parser, Errors.KeywordNotId);
-  }
-
-  if (context & (Context.InAwaitContext | Context.Module) && t === Token.AwaitKeyword) {
-    report(parser, Errors.AwaitOutsideAsync);
-  }
-
-  if (context & (Context.InYieldContext | Context.Strict) && t === Token.YieldKeyword) {
-    report(parser, Errors.DisallowedInContext, 'yield');
-  }
-}
-
-/**
- * Validates binding identifier
- *
- * @param parser Parser state
- * @param context Context masks
- * @param t Token
- */
-
-export function isStrictReservedWord(parser: ParserState, context: Context, t: Token): boolean {
-  if (t === Token.AwaitKeyword) {
-    if (context & (Context.InAwaitContext | Context.Module)) report(parser, Errors.AwaitOutsideAsync);
-    parser.destructible |= DestructuringKind.Await;
-  }
-
-  if (t === Token.YieldKeyword && context & Context.InYieldContext) report(parser, Errors.DisallowedInContext, 'yield');
-
-  return (
-    (t & Token.Reserved) === Token.Reserved ||
-    (t & Token.FutureReserved) === Token.FutureReserved ||
-    t == Token.EscapedFutureReserved
-  );
-}
-
-/**
- * Checks if the property has any private field key
- *
- * @param parser Parser object
- * @param context  Context masks
- */
-export function isPropertyWithPrivateFieldKey(expr: any): boolean {
-  return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
-}
-
-/**
- * Checks if a label in `LabelledStatement` are valid or not
- *
- * @param parser Parser state
- * @param labels Object holding the labels
- * @param name Current label
- * @param isIterationStatement
- */
-export function isValidLabel(parser: ParserState, labels: any, name: string, isIterationStatement: 0 | 1): 0 | 1 {
-  while (labels) {
-    if (labels['$' + name]) {
-      if (isIterationStatement) report(parser, Errors.InvalidNestedStatement);
-      return 1;
-    }
-    if (isIterationStatement && labels.loop) isIterationStatement = 0;
-    labels = labels['$'];
-  }
-
-  return 0;
-}
-
-/**
- * Checks if current label already have been declrared, and if not
- * declare it
- *
- * @param parser Parser state
- * @param labels Object holding the labels
- * @param name Current label
- */
-export function validateAndDeclareLabel(parser: ParserState, labels: any, name: string): void {
-  let set = labels;
-  while (set) {
-    if (set['$' + name]) report(parser, Errors.LabelRedeclaration, name);
-    set = set['$'];
-  }
-
-  labels['$' + name] = 1;
-}
-
-export function finishNode<T extends Node>(
-  parser: ParserState,
-  context: Context,
-  start: number,
-  line: number,
-  column: number,
-  node: T
-): T {
-  if (context & Context.OptionsRanges) {
-    node.start = start;
-    node.end = parser.startPos;
-    node.range = [start, parser.startPos];
-  }
-
-  if (context & Context.OptionsLoc) {
-    node.loc = {
-      start: {
-        line,
-        column
-      },
-      end: {
-        line: parser.startLine,
-        column: parser.startColumn
-      }
-    };
-
-    if (parser.sourceFile) {
-      node.loc.source = parser.sourceFile;
-    }
-  }
-
-  return node;
-}
-
-/** @internal */
-export function isEqualTagName(elementName: any): any {
-  switch (elementName.type) {
-    case 'JSXIdentifier':
-      return elementName.name;
-    case 'JSXNamespacedName':
-      return elementName.namespace + ':' + elementName.name;
-    case 'JSXMemberExpression':
-      return isEqualTagName(elementName.object) + '.' + isEqualTagName(elementName.property);
-    /* istanbul ignore next */
-    default:
-    // ignore
-  }
-}
-
-/**
- * Create a parsing scope for arrow head, and add lexical binding
- *
- * @param parser Parser state
- * @param context Context masks
- * @param value Binding name to be declared
- */
-export function createArrowHeadParsingScope(parser: ParserState, context: Context, value: string): ScopeState {
-  const scope = addChildScope(createScope(), ScopeKind.ArrowParams);
-  addBlockName(parser, context, scope, value, BindingKind.ArgumentList, Origin.None);
-  return scope;
-}
-
-/**
- * Record duplicate binding errors that may occur in a arrow head or function parameters
- *
- * @param parser Parser state
- * @param type Errors type
- */
-export function recordScopeError(parser: ParserState, type: Errors, ...params: string[]): ScopeError {
-  const { index, line, column } = parser;
-  return {
-    type,
-    params,
-    index,
-    line,
-    column
-  };
-}
-
-/**
- * Creates a block scope
- */
-export function createScope(): ScopeState {
-  return {
-    parent: void 0,
-    type: ScopeKind.Block
-  };
-}
-
-/**
- * Inherit scope
- *
- * @param scope Parser object
- * @param type Scope kind
- */
-export function addChildScope(parent: ScopeState | undefined, type: ScopeKind): ScopeState {
-  return {
-    parent,
-    type,
-    scopeError: void 0
-  };
-}
-
-/**
- * Adds either a var binding or a block scoped binding.
- *
- * @param parser Parser state
- * @param context Context masks
- * @param scope Scope state
- * @param name Binding name
- * @param type Binding kind
- * @param origin Binding Origin
- */
-export function addVarOrBlock(
-  parser: ParserState,
-  context: Context,
-  scope: ScopeState,
-  name: string,
-  kind: BindingKind,
-  origin: Origin
-) {
-  if (kind & BindingKind.Variable) {
-    addVarName(parser, context, scope, name, kind);
-  } else {
-    addBlockName(parser, context, scope, name, kind, origin);
-  }
-  if (origin & Origin.Export) {
-    declareUnboundVariable(parser, name);
-  }
-}
-
-/**
- * Adds block scoped binding
- *
- * @param parser Parser state
- * @param context Context masks
- * @param scope Scope state
- * @param name Binding name
- * @param type Binding kind
- * @param origin Binding Origin
- */
-export function addBlockName(
-  parser: ParserState,
-  context: Context,
-  scope: any,
-  name: string,
-  kind: BindingKind,
-  origin: Origin
-) {
-  const value = (scope as any)['#' + name];
-
-  if (value && (value & BindingKind.Empty) === 0) {
-    if (kind & BindingKind.ArgumentList) {
-      scope.scopeError = recordScopeError(parser, Errors.DuplicateBinding, name);
-    } else if (
-      context & Context.OptionsWebCompat &&
-      value & BindingKind.FunctionLexical &&
-      origin & Origin.BlockStatement
-    ) {
-      // No op
-    } else {
-      report(parser, Errors.DuplicateBinding, name);
-    }
-  }
-
-  if (
-    scope.type & ScopeKind.FunctionBody &&
-    (scope as any).parent['#' + name] &&
-    ((scope as any).parent['#' + name] & BindingKind.Empty) === 0
-  ) {
-    report(parser, Errors.DuplicateBinding, name);
-  }
-
-  if (scope.type & ScopeKind.ArrowParams && value && (value & BindingKind.Empty) === 0) {
-    if (kind & BindingKind.ArgumentList) {
-      scope.scopeError = recordScopeError(parser, Errors.DuplicateBinding, name);
-    }
-  }
-
-  if (scope.type & ScopeKind.CatchBlock) {
-    if ((scope as any).parent['#' + name] & BindingKind.CatchIdentifierOrPattern)
-      report(parser, Errors.ShadowedCatchClause, name);
-  }
-
-  (scope as any)['#' + name] = kind;
-}
-
-/**
- * Adds a variable binding
- *
- * @param parser Parser state
- * @param context Context masks
- * @param scope Scope state
- * @param name Binding name
- * @param type Binding kind
- */
-export function addVarName(
-  parser: ParserState,
-  context: Context,
-  scope: ScopeState,
-  name: string,
-  kind: BindingKind
-): void {
-  let currentScope: any = scope;
-
-  while (currentScope && (currentScope.type & ScopeKind.FunctionRoot) === 0) {
-    const value: ScopeKind = currentScope['#' + name];
-
-    if (value & BindingKind.LexicalBinding) {
-      if (
-        context & Context.OptionsWebCompat &&
-        (context & Context.Strict) === 0 &&
-        ((kind & BindingKind.FunctionStatement && value & BindingKind.LexicalOrFunction) ||
-          (value & BindingKind.FunctionStatement && kind & BindingKind.LexicalOrFunction))
-      ) {
-        // No op
-      } else {
-        report(parser, Errors.DuplicateBinding, name);
-      }
-    }
-    if (currentScope === scope) {
-      if (value & BindingKind.ArgumentList && kind & BindingKind.ArgumentList) {
-        currentScope.scopeError = recordScopeError(parser, Errors.DuplicateBinding, name);
-      }
-    }
-    if (value & (BindingKind.CatchIdentifier | BindingKind.CatchPattern)) {
-      if (
-        (value & BindingKind.CatchIdentifier) === 0 ||
-        (context & Context.OptionsWebCompat) === 0 ||
-        context & Context.Strict
-      ) {
-        report(parser, Errors.DuplicateBinding, name);
-      }
-    }
-
-    currentScope['#' + name] = kind;
-
-    currentScope = currentScope.parent;
-  }
-}
-
-/**
- * Appends a name to the `ExportedNames` of the `ExportsList`, and checks
- * for duplicates
- *
- * @see [Link](https://tc39.github.io/ecma262/$sec-exports-static-semantics-exportednames)
- *
- * @param parser Parser object
- * @param name Exported name
- */
-export function declareUnboundVariable(parser: ParserState, name: string): void {
-  if (parser.exportedNames !== void 0 && name !== '') {
-    if (parser.exportedNames['#' + name]) {
-      report(parser, Errors.DuplicateExportBinding, name);
-    }
-    parser.exportedNames['#' + name] = 1;
-  }
-}
-
-/**
- * Appends a name to the `ExportedBindings` of the `ExportsList`,
- *
- * @see [Link](https://tc39.es/ecma262/$sec-exports-static-semantics-exportedbindings)
- *
- * @param parser Parser object
- * @param name Exported binding name
- */
-export function addBindingToExports(parser: ParserState, name: string): void {
-  if (parser.exportedBindings !== void 0 && name !== '') {
-    parser.exportedBindings['#' + name] = 1;
-  }
-}
-
-export function pushComment(context: Context, array: any[]): any {
-  return function (type: string, value: string, start: number, end: number, loc: SourceLocation) {
-    const comment: any = {
-      type,
-      value
-    };
-
-    if (context & Context.OptionsRanges) {
-      comment.start = start;
-      comment.end = end;
-      comment.range = [start, end];
-    }
-    if (context & Context.OptionsLoc) {
-      comment.loc = loc;
-    }
-    array.push(comment);
-  };
-}
-
-export function pushToken(context: Context, array: any[]): any {
-  return function (token: string, start: number, end: number, loc: SourceLocation) {
-    const tokens: any = {
-      token
-    };
-
-    if (context & Context.OptionsRanges) {
-      tokens.start = start;
-      tokens.end = end;
-      tokens.range = [start, end];
-    }
-    if (context & Context.OptionsLoc) {
-      tokens.loc = loc;
-    }
-    array.push(tokens);
-  };
-}
-
-export function isValidIdentifier(context: Context, t: Token): boolean {
-  if (context & (Context.Strict | Context.InYieldContext)) {
-    // Module code is also "strict mode code"
-    if (context & Context.Module && t === Token.AwaitKeyword) return false;
-    if (context & Context.InYieldContext && t === Token.YieldKeyword) return false;
-    return (t & Token.IsIdentifier) === Token.IsIdentifier || (t & Token.Contextual) === Token.Contextual;
-  }
-
-  return (
-    (t & Token.IsIdentifier) === Token.IsIdentifier ||
-    (t & Token.Contextual) === Token.Contextual ||
-    (t & Token.FutureReserved) === Token.FutureReserved
-  );
-}
-
-export function classifyIdentifier(parser: ParserState, context: Context, t: Token): any {
-  if ((t & Token.IsEvalOrArguments) === Token.IsEvalOrArguments) {
-    if (context & Context.Strict) report(parser, Errors.StrictEvalArguments);
-    parser.flags |= Flags.StrictEvalArguments;
-  }
-
-  if (!isValidIdentifier(context, t)) report(parser, Errors.Unexpected);
-}