aboutsummaryrefslogtreecommitdiff
path: root/node_modules/meriyah/src/lexer
diff options
context:
space:
mode:
authorMinteck <nekostarfan@gmail.com>2021-08-24 14:41:48 +0200
committerMinteck <nekostarfan@gmail.com>2021-08-24 14:41:48 +0200
commitd25e11bee6ca5ca523884da132d18e1400e077b9 (patch)
tree8af39fde19f7ed640a60fb397c7edd647dff1c4c /node_modules/meriyah/src/lexer
downloadkartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.gz
kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.bz2
kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.zip
Initial commit
Diffstat (limited to 'node_modules/meriyah/src/lexer')
-rw-r--r--node_modules/meriyah/src/lexer/charClassifier.ts449
-rw-r--r--node_modules/meriyah/src/lexer/comments.ts178
-rw-r--r--node_modules/meriyah/src/lexer/common.ts140
-rw-r--r--node_modules/meriyah/src/lexer/decodeHTML.ts2186
-rw-r--r--node_modules/meriyah/src/lexer/identifier.ts177
-rw-r--r--node_modules/meriyah/src/lexer/index.ts32
-rw-r--r--node_modules/meriyah/src/lexer/jsx.ts126
-rw-r--r--node_modules/meriyah/src/lexer/numeric.ts259
-rw-r--r--node_modules/meriyah/src/lexer/regexp.ts143
-rw-r--r--node_modules/meriyah/src/lexer/scan.ts655
-rw-r--r--node_modules/meriyah/src/lexer/string.ts242
-rw-r--r--node_modules/meriyah/src/lexer/template.ts108
12 files changed, 4695 insertions, 0 deletions
diff --git a/node_modules/meriyah/src/lexer/charClassifier.ts b/node_modules/meriyah/src/lexer/charClassifier.ts
new file mode 100644
index 0000000..eb31389
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/charClassifier.ts
@@ -0,0 +1,449 @@
+import { unicodeLookup } from '../unicode';
+import { Chars } from '../chars';
+
+export const enum CharFlags {
+ None = 0,
+ IdentifierStart = 1 << 0,
+ IdentifierPart = 1 << 1,
+ KeywordCandidate = 1 << 2,
+ LineTerminator = 1 << 3, // ECMA-262 11.3 Line Terminators
+ Decimal = 1 << 4,
+ Octal = 1 << 5,
+ Hex = 1 << 6,
+ Binary = 1 << 7,
+ Exponent = 1 << 8,
+ ImplicitOctalDigits = 1 << 9,
+ CarriageReturn = 1 << 10,
+ LineFeed = 1 << 11,
+ Underscore = 1 << 12,
+ StringLiteral = 1 << 13,
+ JSXToken = 1 << 14,
+ Hyphen = 1 << 15,
+}
+
+/**
+ * Lookup table for mapping a codepoint to a set of flags
+ */
+export const CharTypes = [
+ CharFlags.None /* 0x00 */,
+ CharFlags.None /* 0x01 */,
+ CharFlags.None /* 0x02 */,
+ CharFlags.None /* 0x03 */,
+ CharFlags.None /* 0x04 */,
+ CharFlags.None /* 0x05 */,
+ CharFlags.None /* 0x06 */,
+ CharFlags.None /* 0x07 */,
+ CharFlags.None /* 0x08 */,
+ CharFlags.None /* 0x09 */,
+ CharFlags.LineTerminator | CharFlags.CarriageReturn /* 0x0A */,
+ CharFlags.None /* 0x0B */,
+ CharFlags.None /* 0x0C */,
+ CharFlags.LineTerminator | CharFlags.LineFeed /* 0x0D */,
+ CharFlags.None /* 0x0E */,
+ CharFlags.None /* 0x0F */,
+ CharFlags.None /* 0x10 */,
+ CharFlags.None /* 0x11 */,
+ CharFlags.None /* 0x12 */,
+ CharFlags.None /* 0x13 */,
+ CharFlags.None /* 0x14 */,
+ CharFlags.None /* 0x15 */,
+ CharFlags.None /* 0x16 */,
+ CharFlags.None /* 0x17 */,
+ CharFlags.None /* 0x18 */,
+ CharFlags.None /* 0x19 */,
+ CharFlags.None /* 0x1A */,
+ CharFlags.None /* 0x1B */,
+ CharFlags.None /* 0x1C */,
+ CharFlags.None /* 0x1D */,
+ CharFlags.None /* 0x1E */,
+ CharFlags.None /* 0x1F */,
+ CharFlags.None /* 0x20 */,
+ CharFlags.None /* 0x21 ! */,
+ CharFlags.StringLiteral /* 0x22 */,
+ CharFlags.None /* 0x23 # */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x24 $ */,
+ CharFlags.None /* 0x25 % */,
+ CharFlags.None /* 0x26 & */,
+ CharFlags.StringLiteral /* 0x27 */,
+ CharFlags.None /* 0x28 */,
+ CharFlags.None /* 0x29 */,
+ CharFlags.None /* 0x2A */,
+ CharFlags.Exponent /* 0x2B */,
+ CharFlags.None /* 0x2C */,
+ CharFlags.Exponent | CharFlags.Hyphen /* 0x2D */,
+ CharFlags.None /* 0x2E */,
+ CharFlags.None /* 0x2F */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Binary | CharFlags.Octal | CharFlags.Hex /* 0x30 0 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Binary | CharFlags.Octal | CharFlags.Hex /* 0x31 1 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x32 2 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x33 3 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x34 4 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x35 5 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x36 6 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.Octal | CharFlags.Hex /* 0x37 7 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.ImplicitOctalDigits | CharFlags.Hex /* 0x38 8 */,
+ CharFlags.IdentifierPart | CharFlags.Decimal | CharFlags.ImplicitOctalDigits | CharFlags.Hex /* 0x39 9 */,
+ CharFlags.None /* 0x3A */,
+ CharFlags.None /* 0x3B */,
+ CharFlags.JSXToken /* 0x3C < */,
+ CharFlags.None /* 0x3D = */,
+ CharFlags.None /* 0x3E > */,
+ CharFlags.None /* 0x3F */,
+ CharFlags.None /* 0x40 @ */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x41 A */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x42 B */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x43 C */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x44 D */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x45 E */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Hex /* 0x46 F */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x47 G */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x48 H */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x49 I */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4A J */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4B K */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4C L */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4D M */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4E N */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x4F O */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x50 P */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x51 Q */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x52 R */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x53 S */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x54 T */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x55 U */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x56 V */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x57 W */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x58 X */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x59 Y */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart /* 0x5A Z */,
+ CharFlags.None /* 0x5B */,
+ CharFlags.IdentifierStart /* 0x5C */,
+ CharFlags.None /* 0x5D */,
+ CharFlags.None /* 0x5E */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.Underscore/* 0x5F _ */,
+ CharFlags.None /* 0x60 */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x61 a */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x62 b */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x63 c */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x64 d */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x65 e */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate | CharFlags.Hex /* 0x66 f */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x67 g */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x68 h */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x69 i */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6A j */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6B k */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6C l */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6D m */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6E n */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x6F o */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x70 p */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x71 q */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x72 r */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x73 s */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x74 t */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x75 u */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x76 v */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x77 w */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x78 x */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x79 y */,
+ CharFlags.IdentifierStart | CharFlags.IdentifierPart | CharFlags.KeywordCandidate /* 0x7A z */,
+ CharFlags.JSXToken /* 0x7B */,
+ CharFlags.None /* 0x7C */,
+ CharFlags.None /* 0x7D */,
+ CharFlags.None /* 0x7E */,
+ CharFlags.None /* 0x7F */
+];
+
+export const isIdStart = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+];
+
+export const isIdPart = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+];
+
+
+export function isIdentifierStart(code: number): number {
+ /*
+ * ES2020 11.6 IdentifierStart
+ * $ (dollar sign)
+ * _ (underscore)
+ * or any character with the Unicode property «ID_Start».
+ *
+ * We use a lookup table for small and thus common characters for speed.
+ */
+ return code <= 0x7F
+ ? isIdStart[code]
+ : (unicodeLookup[(code >>> 5) + 34816] >>> code) & 31 & 1;
+}
+
+export function isIdentifierPart(code: number): any {
+ /*
+ * ES2020 11.6 IdentifierPart
+ * $ (dollar sign)
+ * _ (underscore)
+ * <ZWNJ>
+ * <ZWJ>
+ * or any character with the Unicode property «ID_Continue».
+ *
+ * We use a lookup table for small and thus common characters for speed.
+ */
+ return code <= 0x7F
+ ? isIdPart[code]
+ : (unicodeLookup[(code >>> 5) + 0] >>> code) & 31 & 1 || (code === Chars.ZeroWidthJoiner || code === Chars.ZeroWidthNonJoiner);
+}
diff --git a/node_modules/meriyah/src/lexer/comments.ts b/node_modules/meriyah/src/lexer/comments.ts
new file mode 100644
index 0000000..fc95da2
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/comments.ts
@@ -0,0 +1,178 @@
+import { advanceChar, LexerState, scanNewLine, consumeLineFeed } from './common';
+import { CharTypes, CharFlags } from './charClassifier';
+import { Chars } from '../chars';
+import { Context, ParserState } from '../common';
+import { report, Errors } from '../errors';
+
+export const enum CommentType {
+ Single,
+ Multi,
+ HTMLOpen,
+ HTMLClose,
+ HashBang
+}
+
+export const CommentTypes = ['SingleLine', 'MultiLine', 'HTMLOpen', 'HTMLClose', 'HashbangComment'];
+
+/**
+ * Skips hasbang (stage 3)
+ *
+ * @param parser Parser object
+ */
+export function skipHashBang(parser: ParserState): void {
+ // HashbangComment ::
+ // #! SingleLineCommentChars_opt
+ const source = parser.source;
+ if (parser.currentChar === Chars.Hash && source.charCodeAt(parser.index + 1) === Chars.Exclamation) {
+ advanceChar(parser);
+ advanceChar(parser);
+ skipSingleLineComment(
+ parser,
+ source,
+ LexerState.None,
+ CommentType.HashBang,
+ parser.tokenPos,
+ parser.linePos,
+ parser.colPos
+ );
+ }
+}
+
+export function skipSingleHTMLComment(
+ parser: ParserState,
+ source: string,
+ state: LexerState,
+ context: Context,
+ type: CommentType,
+ start: number,
+ line: number,
+ column: number
+): LexerState {
+ if (context & Context.Module) report(parser, Errors.Unexpected);
+ return skipSingleLineComment(parser, source, state, type, start, line, column);
+}
+
+/**
+ * Skips single line comment
+ *
+ * @param parser Parser object
+ * @param state Lexer state
+ */
+export function skipSingleLineComment(
+ parser: ParserState,
+ source: string,
+ state: LexerState,
+ type: CommentType,
+ start: number,
+ line: number,
+ column: number
+): LexerState {
+ const { index } = parser;
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ while (parser.index < parser.end) {
+ if (CharTypes[parser.currentChar] & CharFlags.LineTerminator) {
+ const isCR = parser.currentChar === Chars.CarriageReturn;
+ scanNewLine(parser);
+ if (isCR && parser.index < parser.end && parser.currentChar === Chars.LineFeed)
+ parser.currentChar = source.charCodeAt(++parser.index);
+ break;
+ } else if ((parser.currentChar ^ Chars.LineSeparator) <= 1) {
+ scanNewLine(parser);
+ break;
+ }
+ advanceChar(parser);
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ }
+ if (parser.onComment) {
+ const loc = {
+ start: {
+ line,
+ column
+ },
+ end: {
+ line: parser.linePos,
+ column: parser.colPos
+ }
+ };
+ // For Single, start before "//",
+ // For HTMLOpen, start before "<!--",
+ // For HTMLClose, start before "\n-->"
+ parser.onComment(CommentTypes[type & 0xff], source.slice(index, parser.tokenPos), start, parser.tokenPos, loc);
+ }
+ return state | LexerState.NewLine;
+}
+
+/**
+ * Skips multiline comment
+ *
+ * @param parser Parser object
+ * @param state Lexer state
+ */
+export function skipMultiLineComment(parser: ParserState, source: string, state: LexerState): LexerState | void {
+ const { index } = parser;
+ while (parser.index < parser.end) {
+ if (parser.currentChar < 0x2b) {
+ let skippedOneAsterisk = false;
+ while (parser.currentChar === Chars.Asterisk) {
+ if (!skippedOneAsterisk) {
+ state &= ~LexerState.LastIsCR;
+ skippedOneAsterisk = true;
+ }
+ if (advanceChar(parser) === Chars.Slash) {
+ advanceChar(parser);
+ if (parser.onComment) {
+ const loc = {
+ start: {
+ line: parser.linePos,
+ column: parser.colPos
+ },
+ end: {
+ line: parser.line,
+ column: parser.column
+ }
+ };
+ parser.onComment(
+ CommentTypes[CommentType.Multi & 0xff],
+ source.slice(index, parser.index - 2),
+ index - 2, // start before '/*'
+ parser.index, // end after '*/'
+ loc
+ );
+ }
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ return state;
+ }
+ }
+
+ if (skippedOneAsterisk) {
+ continue;
+ }
+
+ if (CharTypes[parser.currentChar] & CharFlags.LineTerminator) {
+ if (parser.currentChar === Chars.CarriageReturn) {
+ state |= LexerState.NewLine | LexerState.LastIsCR;
+ scanNewLine(parser);
+ } else {
+ consumeLineFeed(parser, state);
+ state = (state & ~LexerState.LastIsCR) | LexerState.NewLine;
+ }
+ } else {
+ advanceChar(parser);
+ }
+ } else if ((parser.currentChar ^ Chars.LineSeparator) <= 1) {
+ state = (state & ~LexerState.LastIsCR) | LexerState.NewLine;
+ scanNewLine(parser);
+ } else {
+ state &= ~LexerState.LastIsCR;
+ advanceChar(parser);
+ }
+ }
+
+ report(parser, Errors.UnterminatedComment);
+}
diff --git a/node_modules/meriyah/src/lexer/common.ts b/node_modules/meriyah/src/lexer/common.ts
new file mode 100644
index 0000000..de6f28d
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/common.ts
@@ -0,0 +1,140 @@
+import { Token } from '../token';
+import { Chars } from '../chars';
+import { ParserState, Flags } from '../common';
+import { unicodeLookup } from '../unicode';
+import { report, Errors } from '../errors';
+
+export const enum LexerState {
+ None = 0,
+ NewLine = 1 << 0,
+ LastIsCR = 1 << 2
+}
+
+export const enum NumberKind {
+ ImplicitOctal = 1 << 0,
+ Binary = 1 << 1,
+ Octal = 1 << 2,
+ Hex = 1 << 3,
+ Decimal = 1 << 4,
+ NonOctalDecimal = 1 << 5,
+ Float = 1 << 6,
+ ValidBigIntKind = 1 << 7,
+ DecimalNumberKind = Decimal | NonOctalDecimal
+}
+
+/**
+ * Advances this lexer's current index.
+ *
+ * @param parser The parser instance
+ */
+export function advanceChar(parser: ParserState): number {
+ parser.column++;
+ return (parser.currentChar = parser.source.charCodeAt(++parser.index));
+}
+
+/**
+ * Consumes multi unit code point
+ *
+ * @param parser The parser instance
+ * @param hi Code point to validate
+ */
+export function consumeMultiUnitCodePoint(parser: ParserState, hi: number): 0 | 1 {
+ // See: https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type
+ if ((hi & 0xfc00) !== Chars.LeadSurrogateMin) return 0;
+ const lo = parser.source.charCodeAt(parser.index + 1);
+ if ((lo & 0xfc00) !== 0xdc00) return 0;
+ hi = parser.currentChar = Chars.NonBMPMin + ((hi & 0x3ff) << 10) + (lo & 0x3ff);
+ if (((unicodeLookup[(hi >>> 5) + 0] >>> hi) & 31 & 1) === 0) {
+ report(parser, Errors.IllegalCharacter, fromCodePoint(hi));
+ }
+ parser.index++;
+ parser.column++;
+ return 1;
+}
+
+/**
+ * Use to consume a line feed instead of `scanNewLine`.
+ */
+export function consumeLineFeed(parser: ParserState, state: LexerState): void {
+ parser.currentChar = parser.source.charCodeAt(++parser.index);
+ parser.flags |= Flags.NewLine;
+ if ((state & LexerState.LastIsCR) === 0) {
+ parser.column = 0;
+ parser.line++;
+ }
+}
+
+export function scanNewLine(parser: ParserState): void {
+ parser.flags |= Flags.NewLine;
+ parser.currentChar = parser.source.charCodeAt(++parser.index);
+ parser.column = 0;
+ parser.line++;
+}
+
+// ECMA-262 11.2 White Space
+// gC=Zs, U+0009, U+000B, U+000C, U+FEFF
+export function isExoticECMAScriptWhitespace(ch: number): boolean {
+ return (
+ ch === Chars.NonBreakingSpace ||
+ ch === Chars.ZeroWidthNoBreakSpace ||
+ ch === Chars.NextLine ||
+ ch === Chars.Ogham ||
+ (ch >= Chars.EnQuad && ch <= Chars.ZeroWidthSpace) ||
+ ch === Chars.NarrowNoBreakSpace ||
+ ch === Chars.MathematicalSpace ||
+ ch === Chars.IdeographicSpace ||
+ ch === Chars.ThinSpace ||
+ ch === Chars.ByteOrderMark
+ );
+}
+
+/**
+ * Optimized version of 'fromCodePoint'
+ *
+ * @param {number} code
+ * @returns {string}
+ */
+export function fromCodePoint(codePoint: number): string {
+ return codePoint <= 65535
+ ? String.fromCharCode(codePoint)
+ : String.fromCharCode(codePoint >>> 10) + String.fromCharCode(codePoint & 0x3ff);
+}
+
+/**
+ * Converts a value to a hex value
+ *
+ * @param code CodePoint
+ */
+export function toHex(code: number): number {
+ return code < Chars.UpperA ? code - Chars.Zero : (code - Chars.UpperA + 10) & 0xf;
+}
+
+/**
+ * Converts a token to a string representation
+ *
+ * @param t Token
+ */
+export function convertTokenType(t: Token): string {
+ switch (t) {
+ case Token.NumericLiteral:
+ return 'NumericLiteral';
+ case Token.StringLiteral:
+ return 'StringLiteral';
+ case Token.FalseKeyword:
+ case Token.TrueKeyword:
+ return 'BooleanLiteral';
+ case Token.NullKeyword:
+ return 'NullLiteral';
+ case Token.RegularExpression:
+ return 'RegularExpression';
+ case Token.TemplateContinuation:
+ case Token.TemplateSpan:
+ case Token.Template:
+ return 'TemplateLiteral';
+ default:
+ if ((t & Token.IsIdentifier) === Token.IsIdentifier) return 'Identifier';
+ if ((t & Token.Keyword) === Token.Keyword) return 'Keyword';
+
+ return 'Punctuator';
+ }
+}
diff --git a/node_modules/meriyah/src/lexer/decodeHTML.ts b/node_modules/meriyah/src/lexer/decodeHTML.ts
new file mode 100644
index 0000000..61cda52
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/decodeHTML.ts
@@ -0,0 +1,2186 @@
+// https://html.spec.whatwg.org/entities.json
+const entities: { [Identifier: string]: string } = {
+ AElig: '\u00C6',
+ AMP: '\u0026',
+ Aacute: '\u00C1',
+ Abreve: '\u0102',
+ Acirc: '\u00C2',
+ Acy: '\u0410',
+ Afr: '\uD835\uDD04',
+ Agrave: '\u00C0',
+ Alpha: '\u0391',
+ Amacr: '\u0100',
+ And: '\u2A53',
+ Aogon: '\u0104',
+ Aopf: '\uD835\uDD38',
+ ApplyFunction: '\u2061',
+ Aring: '\u00C5',
+ Ascr: '\uD835\uDC9C',
+ Assign: '\u2254',
+ Atilde: '\u00C3',
+ Auml: '\u00C4',
+ Backslash: '\u2216',
+ Barv: '\u2AE7',
+ Barwed: '\u2306',
+ Bcy: '\u0411',
+ Because: '\u2235',
+ Bernoullis: '\u212C',
+ Beta: '\u0392',
+ Bfr: '\uD835\uDD05',
+ Bopf: '\uD835\uDD39',
+ Breve: '\u02D8',
+ Bscr: '\u212C',
+ Bumpeq: '\u224E',
+ CHcy: '\u0427',
+ COPY: '\u00A9',
+ Cacute: '\u0106',
+ Cap: '\u22D2',
+ CapitalDifferentialD: '\u2145',
+ Cayleys: '\u212D',
+ Ccaron: '\u010C',
+ Ccedil: '\u00C7',
+ Ccirc: '\u0108',
+ Cconint: '\u2230',
+ Cdot: '\u010A',
+ Cedilla: '\u00B8',
+ CenterDot: '\u00B7',
+ Cfr: '\u212D',
+ Chi: '\u03A7',
+ CircleDot: '\u2299',
+ CircleMinus: '\u2296',
+ CirclePlus: '\u2295',
+ CircleTimes: '\u2297',
+ ClockwiseContourIntegral: '\u2232',
+ CloseCurlyDoubleQuote: '\u201D',
+ CloseCurlyQuote: '\u2019',
+ Colon: '\u2237',
+ Colone: '\u2A74',
+ Congruent: '\u2261',
+ Conint: '\u222F',
+ ContourIntegral: '\u222E',
+ Copf: '\u2102',
+ Coproduct: '\u2210',
+ CounterClockwiseContourIntegral: '\u2233',
+ Cross: '\u2A2F',
+ Cscr: '\uD835\uDC9E',
+ Cup: '\u22D3',
+ CupCap: '\u224D',
+ DD: '\u2145',
+ DDotrahd: '\u2911',
+ DJcy: '\u0402',
+ DScy: '\u0405',
+ DZcy: '\u040F',
+ Dagger: '\u2021',
+ Darr: '\u21A1',
+ Dashv: '\u2AE4',
+ Dcaron: '\u010E',
+ Dcy: '\u0414',
+ Del: '\u2207',
+ Delta: '\u0394',
+ Dfr: '\uD835\uDD07',
+ DiacriticalAcute: '\u00B4',
+ DiacriticalDot: '\u02D9',
+ DiacriticalDoubleAcute: '\u02DD',
+ DiacriticalGrave: '\u0060',
+ DiacriticalTilde: '\u02DC',
+ Diamond: '\u22C4',
+ DifferentialD: '\u2146',
+ Dopf: '\uD835\uDD3B',
+ Dot: '\u00A8',
+ DotDot: '\u20DC',
+ DotEqual: '\u2250',
+ DoubleContourIntegral: '\u222F',
+ DoubleDot: '\u00A8',
+ DoubleDownArrow: '\u21D3',
+ DoubleLeftArrow: '\u21D0',
+ DoubleLeftRightArrow: '\u21D4',
+ DoubleLeftTee: '\u2AE4',
+ DoubleLongLeftArrow: '\u27F8',
+ DoubleLongLeftRightArrow: '\u27FA',
+ DoubleLongRightArrow: '\u27F9',
+ DoubleRightArrow: '\u21D2',
+ DoubleRightTee: '\u22A8',
+ DoubleUpArrow: '\u21D1',
+ DoubleUpDownArrow: '\u21D5',
+ DoubleVerticalBar: '\u2225',
+ DownArrow: '\u2193',
+ DownArrowBar: '\u2913',
+ DownArrowUpArrow: '\u21F5',
+ DownBreve: '\u0311',
+ DownLeftRightVector: '\u2950',
+ DownLeftTeeVector: '\u295E',
+ DownLeftVector: '\u21BD',
+ DownLeftVectorBar: '\u2956',
+ DownRightTeeVector: '\u295F',
+ DownRightVector: '\u21C1',
+ DownRightVectorBar: '\u2957',
+ DownTee: '\u22A4',
+ DownTeeArrow: '\u21A7',
+ Downarrow: '\u21D3',
+ Dscr: '\uD835\uDC9F',
+ Dstrok: '\u0110',
+ ENG: '\u014A',
+ ETH: '\u00D0',
+ Eacute: '\u00C9',
+ Ecaron: '\u011A',
+ Ecirc: '\u00CA',
+ Ecy: '\u042D',
+ Edot: '\u0116',
+ Efr: '\uD835\uDD08',
+ Egrave: '\u00C8',
+ Element: '\u2208',
+ Emacr: '\u0112',
+ EmptySmallSquare: '\u25FB',
+ EmptyVerySmallSquare: '\u25AB',
+ Eogon: '\u0118',
+ Eopf: '\uD835\uDD3C',
+ Epsilon: '\u0395',
+ Equal: '\u2A75',
+ EqualTilde: '\u2242',
+ Equilibrium: '\u21CC',
+ Escr: '\u2130',
+ Esim: '\u2A73',
+ Eta: '\u0397',
+ Euml: '\u00CB',
+ Exists: '\u2203',
+ ExponentialE: '\u2147',
+ Fcy: '\u0424',
+ Ffr: '\uD835\uDD09',
+ FilledSmallSquare: '\u25FC',
+ FilledVerySmallSquare: '\u25AA',
+ Fopf: '\uD835\uDD3D',
+ ForAll: '\u2200',
+ Fouriertrf: '\u2131',
+ Fscr: '\u2131',
+ GJcy: '\u0403',
+ GT: '\u003E',
+ Gamma: '\u0393',
+ Gammad: '\u03DC',
+ Gbreve: '\u011E',
+ Gcedil: '\u0122',
+ Gcirc: '\u011C',
+ Gcy: '\u0413',
+ Gdot: '\u0120',
+ Gfr: '\uD835\uDD0A',
+ Gg: '\u22D9',
+ Gopf: '\uD835\uDD3E',
+ GreaterEqual: '\u2265',
+ GreaterEqualLess: '\u22DB',
+ GreaterFullEqual: '\u2267',
+ GreaterGreater: '\u2AA2',
+ GreaterLess: '\u2277',
+ GreaterSlantEqual: '\u2A7E',
+ GreaterTilde: '\u2273',
+ Gscr: '\uD835\uDCA2',
+ Gt: '\u226B',
+ HARDcy: '\u042A',
+ Hacek: '\u02C7',
+ Hat: '\u005E',
+ Hcirc: '\u0124',
+ Hfr: '\u210C',
+ HilbertSpace: '\u210B',
+ Hopf: '\u210D',
+ HorizontalLine: '\u2500',
+ Hscr: '\u210B',
+ Hstrok: '\u0126',
+ HumpDownHump: '\u224E',
+ HumpEqual: '\u224F',
+ IEcy: '\u0415',
+ IJlig: '\u0132',
+ IOcy: '\u0401',
+ Iacute: '\u00CD',
+ Icirc: '\u00CE',
+ Icy: '\u0418',
+ Idot: '\u0130',
+ Ifr: '\u2111',
+ Igrave: '\u00CC',
+ Im: '\u2111',
+ Imacr: '\u012A',
+ ImaginaryI: '\u2148',
+ Implies: '\u21D2',
+ Int: '\u222C',
+ Integral: '\u222B',
+ Intersection: '\u22C2',
+ InvisibleComma: '\u2063',
+ InvisibleTimes: '\u2062',
+ Iogon: '\u012E',
+ Iopf: '\uD835\uDD40',
+ Iota: '\u0399',
+ Iscr: '\u2110',
+ Itilde: '\u0128',
+ Iukcy: '\u0406',
+ Iuml: '\u00CF',
+ Jcirc: '\u0134',
+ Jcy: '\u0419',
+ Jfr: '\uD835\uDD0D',
+ Jopf: '\uD835\uDD41',
+ Jscr: '\uD835\uDCA5',
+ Jsercy: '\u0408',
+ Jukcy: '\u0404',
+ KHcy: '\u0425',
+ KJcy: '\u040C',
+ Kappa: '\u039A',
+ Kcedil: '\u0136',
+ Kcy: '\u041A',
+ Kfr: '\uD835\uDD0E',
+ Kopf: '\uD835\uDD42',
+ Kscr: '\uD835\uDCA6',
+ LJcy: '\u0409',
+ LT: '\u003C',
+ Lacute: '\u0139',
+ Lambda: '\u039B',
+ Lang: '\u27EA',
+ Laplacetrf: '\u2112',
+ Larr: '\u219E',
+ Lcaron: '\u013D',
+ Lcedil: '\u013B',
+ Lcy: '\u041B',
+ LeftAngleBracket: '\u27E8',
+ LeftArrow: '\u2190',
+ LeftArrowBar: '\u21E4',
+ LeftArrowRightArrow: '\u21C6',
+ LeftCeiling: '\u2308',
+ LeftDoubleBracket: '\u27E6',
+ LeftDownTeeVector: '\u2961',
+ LeftDownVector: '\u21C3',
+ LeftDownVectorBar: '\u2959',
+ LeftFloor: '\u230A',
+ LeftRightArrow: '\u2194',
+ LeftRightVector: '\u294E',
+ LeftTee: '\u22A3',
+ LeftTeeArrow: '\u21A4',
+ LeftTeeVector: '\u295A',
+ LeftTriangle: '\u22B2',
+ LeftTriangleBar: '\u29CF',
+ LeftTriangleEqual: '\u22B4',
+ LeftUpDownVector: '\u2951',
+ LeftUpTeeVector: '\u2960',
+ LeftUpVector: '\u21BF',
+ LeftUpVectorBar: '\u2958',
+ LeftVector: '\u21BC',
+ LeftVectorBar: '\u2952',
+ Leftarrow: '\u21D0',
+ Leftrightarrow: '\u21D4',
+ LessEqualGreater: '\u22DA',
+ LessFullEqual: '\u2266',
+ LessGreater: '\u2276',
+ LessLess: '\u2AA1',
+ LessSlantEqual: '\u2A7D',
+ LessTilde: '\u2272',
+ Lfr: '\uD835\uDD0F',
+ Ll: '\u22D8',
+ Lleftarrow: '\u21DA',
+ Lmidot: '\u013F',
+ LongLeftArrow: '\u27F5',
+ LongLeftRightArrow: '\u27F7',
+ LongRightArrow: '\u27F6',
+ Longleftarrow: '\u27F8',
+ Longleftrightarrow: '\u27FA',
+ Longrightarrow: '\u27F9',
+ Lopf: '\uD835\uDD43',
+ LowerLeftArrow: '\u2199',
+ LowerRightArrow: '\u2198',
+ Lscr: '\u2112',
+ Lsh: '\u21B0',
+ Lstrok: '\u0141',
+ Lt: '\u226A',
+ Map: '\u2905',
+ Mcy: '\u041C',
+ MediumSpace: '\u205F',
+ Mellintrf: '\u2133',
+ Mfr: '\uD835\uDD10',
+ MinusPlus: '\u2213',
+ Mopf: '\uD835\uDD44',
+ Mscr: '\u2133',
+ Mu: '\u039C',
+ NJcy: '\u040A',
+ Nacute: '\u0143',
+ Ncaron: '\u0147',
+ Ncedil: '\u0145',
+ Ncy: '\u041D',
+ NegativeMediumSpace: '\u200B',
+ NegativeThickSpace: '\u200B',
+ NegativeThinSpace: '\u200B',
+ NegativeVeryThinSpace: '\u200B',
+ NestedGreaterGreater: '\u226B',
+ NestedLessLess: '\u226A',
+ NewLine: '\u000A',
+ Nfr: '\uD835\uDD11',
+ NoBreak: '\u2060',
+ NonBreakingSpace: '\u00A0',
+ Nopf: '\u2115',
+ Not: '\u2AEC',
+ NotCongruent: '\u2262',
+ NotCupCap: '\u226D',
+ NotDoubleVerticalBar: '\u2226',
+ NotElement: '\u2209',
+ NotEqual: '\u2260',
+ NotEqualTilde: '\u2242\u0338',
+ NotExists: '\u2204',
+ NotGreater: '\u226F',
+ NotGreaterEqual: '\u2271',
+ NotGreaterFullEqual: '\u2267\u0338',
+ NotGreaterGreater: '\u226B\u0338',
+ NotGreaterLess: '\u2279',
+ NotGreaterSlantEqual: '\u2A7E\u0338',
+ NotGreaterTilde: '\u2275',
+ NotHumpDownHump: '\u224E\u0338',
+ NotHumpEqual: '\u224F\u0338',
+ NotLeftTriangle: '\u22EA',
+ NotLeftTriangleBar: '\u29CF\u0338',
+ NotLeftTriangleEqual: '\u22EC',
+ NotLess: '\u226E',
+ NotLessEqual: '\u2270',
+ NotLessGreater: '\u2278',
+ NotLessLess: '\u226A\u0338',
+ NotLessSlantEqual: '\u2A7D\u0338',
+ NotLessTilde: '\u2274',
+ NotNestedGreaterGreater: '\u2AA2\u0338',
+ NotNestedLessLess: '\u2AA1\u0338',
+ NotPrecedes: '\u2280',
+ NotPrecedesEqual: '\u2AAF\u0338',
+ NotPrecedesSlantEqual: '\u22E0',
+ NotReverseElement: '\u220C',
+ NotRightTriangle: '\u22EB',
+ NotRightTriangleBar: '\u29D0\u0338',
+ NotRightTriangleEqual: '\u22ED',
+ NotSquareSubset: '\u228F\u0338',
+ NotSquareSubsetEqual: '\u22E2',
+ NotSquareSuperset: '\u2290\u0338',
+ NotSquareSupersetEqual: '\u22E3',
+ NotSubset: '\u2282\u20D2',
+ NotSubsetEqual: '\u2288',
+ NotSucceeds: '\u2281',
+ NotSucceedsEqual: '\u2AB0\u0338',
+ NotSucceedsSlantEqual: '\u22E1',
+ NotSucceedsTilde: '\u227F\u0338',
+ NotSuperset: '\u2283\u20D2',
+ NotSupersetEqual: '\u2289',
+ NotTilde: '\u2241',
+ NotTildeEqual: '\u2244',
+ NotTildeFullEqual: '\u2247',
+ NotTildeTilde: '\u2249',
+ NotVerticalBar: '\u2224',
+ Nscr: '\uD835\uDCA9',
+ Ntilde: '\u00D1',
+ Nu: '\u039D',
+ OElig: '\u0152',
+ Oacute: '\u00D3',
+ Ocirc: '\u00D4',
+ Ocy: '\u041E',
+ Odblac: '\u0150',
+ Ofr: '\uD835\uDD12',
+ Ograve: '\u00D2',
+ Omacr: '\u014C',
+ Omega: '\u03A9',
+ Omicron: '\u039F',
+ Oopf: '\uD835\uDD46',
+ OpenCurlyDoubleQuote: '\u201C',
+ OpenCurlyQuote: '\u2018',
+ Or: '\u2A54',
+ Oscr: '\uD835\uDCAA',
+ Oslash: '\u00D8',
+ Otilde: '\u00D5',
+ Otimes: '\u2A37',
+ Ouml: '\u00D6',
+ OverBar: '\u203E',
+ OverBrace: '\u23DE',
+ OverBracket: '\u23B4',
+ OverParenthesis: '\u23DC',
+ PartialD: '\u2202',
+ Pcy: '\u041F',
+ Pfr: '\uD835\uDD13',
+ Phi: '\u03A6',
+ Pi: '\u03A0',
+ PlusMinus: '\u00B1',
+ Poincareplane: '\u210C',
+ Popf: '\u2119',
+ Pr: '\u2ABB',
+ Precedes: '\u227A',
+ PrecedesEqual: '\u2AAF',
+ PrecedesSlantEqual: '\u227C',
+ PrecedesTilde: '\u227E',
+ Prime: '\u2033',
+ Product: '\u220F',
+ Proportion: '\u2237',
+ Proportional: '\u221D',
+ Pscr: '\uD835\uDCAB',
+ Psi: '\u03A8',
+ QUOT: '\u0022',
+ Qfr: '\uD835\uDD14',
+ Qopf: '\u211A',
+ Qscr: '\uD835\uDCAC',
+ RBarr: '\u2910',
+ REG: '\u00AE',
+ Racute: '\u0154',
+ Rang: '\u27EB',
+ Rarr: '\u21A0',
+ Rarrtl: '\u2916',
+ Rcaron: '\u0158',
+ Rcedil: '\u0156',
+ Rcy: '\u0420',
+ Re: '\u211C',
+ ReverseElement: '\u220B',
+ ReverseEquilibrium: '\u21CB',
+ ReverseUpEquilibrium: '\u296F',
+ Rfr: '\u211C',
+ Rho: '\u03A1',
+ RightAngleBracket: '\u27E9',
+ RightArrow: '\u2192',
+ RightArrowBar: '\u21E5',
+ RightArrowLeftArrow: '\u21C4',
+ RightCeiling: '\u2309',
+ RightDoubleBracket: '\u27E7',
+ RightDownTeeVector: '\u295D',
+ RightDownVector: '\u21C2',
+ RightDownVectorBar: '\u2955',
+ RightFloor: '\u230B',
+ RightTee: '\u22A2',
+ RightTeeArrow: '\u21A6',
+ RightTeeVector: '\u295B',
+ RightTriangle: '\u22B3',
+ RightTriangleBar: '\u29D0',
+ RightTriangleEqual: '\u22B5',
+ RightUpDownVector: '\u294F',
+ RightUpTeeVector: '\u295C',
+ RightUpVector: '\u21BE',
+ RightUpVectorBar: '\u2954',
+ RightVector: '\u21C0',
+ RightVectorBar: '\u2953',
+ Rightarrow: '\u21D2',
+ Ropf: '\u211D',
+ RoundImplies: '\u2970',
+ Rrightarrow: '\u21DB',
+ Rscr: '\u211B',
+ Rsh: '\u21B1',
+ RuleDelayed: '\u29F4',
+ SHCHcy: '\u0429',
+ SHcy: '\u0428',
+ SOFTcy: '\u042C',
+ Sacute: '\u015A',
+ Sc: '\u2ABC',
+ Scaron: '\u0160',
+ Scedil: '\u015E',
+ Scirc: '\u015C',
+ Scy: '\u0421',
+ Sfr: '\uD835\uDD16',
+ ShortDownArrow: '\u2193',
+ ShortLeftArrow: '\u2190',
+ ShortRightArrow: '\u2192',
+ ShortUpArrow: '\u2191',
+ Sigma: '\u03A3',
+ SmallCircle: '\u2218',
+ Sopf: '\uD835\uDD4A',
+ Sqrt: '\u221A',
+ Square: '\u25A1',
+ SquareIntersection: '\u2293',
+ SquareSubset: '\u228F',
+ SquareSubsetEqual: '\u2291',
+ SquareSuperset: '\u2290',
+ SquareSupersetEqual: '\u2292',
+ SquareUnion: '\u2294',
+ Sscr: '\uD835\uDCAE',
+ Star: '\u22C6',
+ Sub: '\u22D0',
+ Subset: '\u22D0',
+ SubsetEqual: '\u2286',
+ Succeeds: '\u227B',
+ SucceedsEqual: '\u2AB0',
+ SucceedsSlantEqual: '\u227D',
+ SucceedsTilde: '\u227F',
+ SuchThat: '\u220B',
+ Sum: '\u2211',
+ Sup: '\u22D1',
+ Superset: '\u2283',
+ SupersetEqual: '\u2287',
+ Supset: '\u22D1',
+ THORN: '\u00DE',
+ TRADE: '\u2122',
+ TSHcy: '\u040B',
+ TScy: '\u0426',
+ Tab: '\u0009',
+ Tau: '\u03A4',
+ Tcaron: '\u0164',
+ Tcedil: '\u0162',
+ Tcy: '\u0422',
+ Tfr: '\uD835\uDD17',
+ Therefore: '\u2234',
+ Theta: '\u0398',
+ ThickSpace: '\u205F\u200A',
+ ThinSpace: '\u2009',
+ Tilde: '\u223C',
+ TildeEqual: '\u2243',
+ TildeFullEqual: '\u2245',
+ TildeTilde: '\u2248',
+ Topf: '\uD835\uDD4B',
+ TripleDot: '\u20DB',
+ Tscr: '\uD835\uDCAF',
+ Tstrok: '\u0166',
+ Uacute: '\u00DA',
+ Uarr: '\u219F',
+ Uarrocir: '\u2949',
+ Ubrcy: '\u040E',
+ Ubreve: '\u016C',
+ Ucirc: '\u00DB',
+ Ucy: '\u0423',
+ Udblac: '\u0170',
+ Ufr: '\uD835\uDD18',
+ Ugrave: '\u00D9',
+ Umacr: '\u016A',
+ UnderBar: '\u005F',
+ UnderBrace: '\u23DF',
+ UnderBracket: '\u23B5',
+ UnderParenthesis: '\u23DD',
+ Union: '\u22C3',
+ UnionPlus: '\u228E',
+ Uogon: '\u0172',
+ Uopf: '\uD835\uDD4C',
+ UpArrow: '\u2191',
+ UpArrowBar: '\u2912',
+ UpArrowDownArrow: '\u21C5',
+ UpDownArrow: '\u2195',
+ UpEquilibrium: '\u296E',
+ UpTee: '\u22A5',
+ UpTeeArrow: '\u21A5',
+ Uparrow: '\u21D1',
+ Updownarrow: '\u21D5',
+ UpperLeftArrow: '\u2196',
+ UpperRightArrow: '\u2197',
+ Upsi: '\u03D2',
+ Upsilon: '\u03A5',
+ Uring: '\u016E',
+ Uscr: '\uD835\uDCB0',
+ Utilde: '\u0168',
+ Uuml: '\u00DC',
+ VDash: '\u22AB',
+ Vbar: '\u2AEB',
+ Vcy: '\u0412',
+ Vdash: '\u22A9',
+ Vdashl: '\u2AE6',
+ Vee: '\u22C1',
+ Verbar: '\u2016',
+ Vert: '\u2016',
+ VerticalBar: '\u2223',
+ VerticalLine: '\u007C',
+ VerticalSeparator: '\u2758',
+ VerticalTilde: '\u2240',
+ VeryThinSpace: '\u200A',
+ Vfr: '\uD835\uDD19',
+ Vopf: '\uD835\uDD4D',
+ Vscr: '\uD835\uDCB1',
+ Vvdash: '\u22AA',
+ Wcirc: '\u0174',
+ Wedge: '\u22C0',
+ Wfr: '\uD835\uDD1A',
+ Wopf: '\uD835\uDD4E',
+ Wscr: '\uD835\uDCB2',
+ Xfr: '\uD835\uDD1B',
+ Xi: '\u039E',
+ Xopf: '\uD835\uDD4F',
+ Xscr: '\uD835\uDCB3',
+ YAcy: '\u042F',
+ YIcy: '\u0407',
+ YUcy: '\u042E',
+ Yacute: '\u00DD',
+ Ycirc: '\u0176',
+ Ycy: '\u042B',
+ Yfr: '\uD835\uDD1C',
+ Yopf: '\uD835\uDD50',
+ Yscr: '\uD835\uDCB4',
+ Yuml: '\u0178',
+ ZHcy: '\u0416',
+ Zacute: '\u0179',
+ Zcaron: '\u017D',
+ Zcy: '\u0417',
+ Zdot: '\u017B',
+ ZeroWidthSpace: '\u200B',
+ Zeta: '\u0396',
+ Zfr: '\u2128',
+ Zopf: '\u2124',
+ Zscr: '\uD835\uDCB5',
+ aacute: '\u00E1',
+ abreve: '\u0103',
+ ac: '\u223E',
+ acE: '\u223E\u0333',
+ acd: '\u223F',
+ acirc: '\u00E2',
+ acute: '\u00B4',
+ acy: '\u0430',
+ aelig: '\u00E6',
+ af: '\u2061',
+ afr: '\uD835\uDD1E',
+ agrave: '\u00E0',
+ alefsym: '\u2135',
+ aleph: '\u2135',
+ alpha: '\u03B1',
+ amacr: '\u0101',
+ amalg: '\u2A3F',
+ amp: '\u0026',
+ and: '\u2227',
+ andand: '\u2A55',
+ andd: '\u2A5C',
+ andslope: '\u2A58',
+ andv: '\u2A5A',
+ ang: '\u2220',
+ ange: '\u29A4',
+ angle: '\u2220',
+ angmsd: '\u2221',
+ angmsdaa: '\u29A8',
+ angmsdab: '\u29A9',
+ angmsdac: '\u29AA',
+ angmsdad: '\u29AB',
+ angmsdae: '\u29AC',
+ angmsdaf: '\u29AD',
+ angmsdag: '\u29AE',
+ angmsdah: '\u29AF',
+ angrt: '\u221F',
+ angrtvb: '\u22BE',
+ angrtvbd: '\u299D',
+ angsph: '\u2222',
+ angst: '\u00C5',
+ angzarr: '\u237C',
+ aogon: '\u0105',
+ aopf: '\uD835\uDD52',
+ ap: '\u2248',
+ apE: '\u2A70',
+ apacir: '\u2A6F',
+ ape: '\u224A',
+ apid: '\u224B',
+ apos: '\u0027',
+ approx: '\u2248',
+ approxeq: '\u224A',
+ aring: '\u00E5',
+ ascr: '\uD835\uDCB6',
+ ast: '\u002A',
+ asymp: '\u2248',
+ asympeq: '\u224D',
+ atilde: '\u00E3',
+ auml: '\u00E4',
+ awconint: '\u2233',
+ awint: '\u2A11',
+ bNot: '\u2AED',
+ backcong: '\u224C',
+ backepsilon: '\u03F6',
+ backprime: '\u2035',
+ backsim: '\u223D',
+ backsimeq: '\u22CD',
+ barvee: '\u22BD',
+ barwed: '\u2305',
+ barwedge: '\u2305',
+ bbrk: '\u23B5',
+ bbrktbrk: '\u23B6',
+ bcong: '\u224C',
+ bcy: '\u0431',
+ bdquo: '\u201E',
+ becaus: '\u2235',
+ because: '\u2235',
+ bemptyv: '\u29B0',
+ bepsi: '\u03F6',
+ bernou: '\u212C',
+ beta: '\u03B2',
+ beth: '\u2136',
+ between: '\u226C',
+ bfr: '\uD835\uDD1F',
+ bigcap: '\u22C2',
+ bigcirc: '\u25EF',
+ bigcup: '\u22C3',
+ bigodot: '\u2A00',
+ bigoplus: '\u2A01',
+ bigotimes: '\u2A02',
+ bigsqcup: '\u2A06',
+ bigstar: '\u2605',
+ bigtriangledown: '\u25BD',
+ bigtriangleup: '\u25B3',
+ biguplus: '\u2A04',
+ bigvee: '\u22C1',
+ bigwedge: '\u22C0',
+ bkarow: '\u290D',
+ blacklozenge: '\u29EB',
+ blacksquare: '\u25AA',
+ blacktriangle: '\u25B4',
+ blacktriangledown: '\u25BE',
+ blacktriangleleft: '\u25C2',
+ blacktriangleright: '\u25B8',
+ blank: '\u2423',
+ blk12: '\u2592',
+ blk14: '\u2591',
+ blk34: '\u2593',
+ block: '\u2588',
+ bne: '\u003D\u20E5',
+ bnequiv: '\u2261\u20E5',
+ bnot: '\u2310',
+ bopf: '\uD835\uDD53',
+ bot: '\u22A5',
+ bottom: '\u22A5',
+ bowtie: '\u22C8',
+ boxDL: '\u2557',
+ boxDR: '\u2554',
+ boxDl: '\u2556',
+ boxDr: '\u2553',
+ boxH: '\u2550',
+ boxHD: '\u2566',
+ boxHU: '\u2569',
+ boxHd: '\u2564',
+ boxHu: '\u2567',
+ boxUL: '\u255D',
+ boxUR: '\u255A',
+ boxUl: '\u255C',
+ boxUr: '\u2559',
+ boxV: '\u2551',
+ boxVH: '\u256C',
+ boxVL: '\u2563',
+ boxVR: '\u2560',
+ boxVh: '\u256B',
+ boxVl: '\u2562',
+ boxVr: '\u255F',
+ boxbox: '\u29C9',
+ boxdL: '\u2555',
+ boxdR: '\u2552',
+ boxdl: '\u2510',
+ boxdr: '\u250C',
+ boxh: '\u2500',
+ boxhD: '\u2565',
+ boxhU: '\u2568',
+ boxhd: '\u252C',
+ boxhu: '\u2534',
+ boxminus: '\u229F',
+ boxplus: '\u229E',
+ boxtimes: '\u22A0',
+ boxuL: '\u255B',
+ boxuR: '\u2558',
+ boxul: '\u2518',
+ boxur: '\u2514',
+ boxv: '\u2502',
+ boxvH: '\u256A',
+ boxvL: '\u2561',
+ boxvR: '\u255E',
+ boxvh: '\u253C',
+ boxvl: '\u2524',
+ boxvr: '\u251C',
+ bprime: '\u2035',
+ breve: '\u02D8',
+ brvbar: '\u00A6',
+ bscr: '\uD835\uDCB7',
+ bsemi: '\u204F',
+ bsim: '\u223D',
+ bsime: '\u22CD',
+ bsol: '\u005C',
+ bsolb: '\u29C5',
+ bsolhsub: '\u27C8',
+ bull: '\u2022',
+ bullet: '\u2022',
+ bump: '\u224E',
+ bumpE: '\u2AAE',
+ bumpe: '\u224F',
+ bumpeq: '\u224F',
+ cacute: '\u0107',
+ cap: '\u2229',
+ capand: '\u2A44',
+ capbrcup: '\u2A49',
+ capcap: '\u2A4B',
+ capcup: '\u2A47',
+ capdot: '\u2A40',
+ caps: '\u2229\uFE00',
+ caret: '\u2041',
+ caron: '\u02C7',
+ ccaps: '\u2A4D',
+ ccaron: '\u010D',
+ ccedil: '\u00E7',
+ ccirc: '\u0109',
+ ccups: '\u2A4C',
+ ccupssm: '\u2A50',
+ cdot: '\u010B',
+ cedil: '\u00B8',
+ cemptyv: '\u29B2',
+ cent: '\u00A2',
+ centerdot: '\u00B7',
+ cfr: '\uD835\uDD20',
+ chcy: '\u0447',
+ check: '\u2713',
+ checkmark: '\u2713',
+ chi: '\u03C7',
+ cir: '\u25CB',
+ cirE: '\u29C3',
+ circ: '\u02C6',
+ circeq: '\u2257',
+ circlearrowleft: '\u21BA',
+ circlearrowright: '\u21BB',
+ circledR: '\u00AE',
+ circledS: '\u24C8',
+ circledast: '\u229B',
+ circledcirc: '\u229A',
+ circleddash: '\u229D',
+ cire: '\u2257',
+ cirfnint: '\u2A10',
+ cirmid: '\u2AEF',
+ cirscir: '\u29C2',
+ clubs: '\u2663',
+ clubsuit: '\u2663',
+ colon: '\u003A',
+ colone: '\u2254',
+ coloneq: '\u2254',
+ comma: '\u002C',
+ commat: '\u0040',
+ comp: '\u2201',
+ compfn: '\u2218',
+ complement: '\u2201',
+ complexes: '\u2102',
+ cong: '\u2245',
+ congdot: '\u2A6D',
+ conint: '\u222E',
+ copf: '\uD835\uDD54',
+ coprod: '\u2210',
+ copy: '\u00A9',
+ copysr: '\u2117',
+ crarr: '\u21B5',
+ cross: '\u2717',
+ cscr: '\uD835\uDCB8',
+ csub: '\u2ACF',
+ csube: '\u2AD1',
+ csup: '\u2AD0',
+ csupe: '\u2AD2',
+ ctdot: '\u22EF',
+ cudarrl: '\u2938',
+ cudarrr: '\u2935',
+ cuepr: '\u22DE',
+ cuesc: '\u22DF',
+ cularr: '\u21B6',
+ cularrp: '\u293D',
+ cup: '\u222A',
+ cupbrcap: '\u2A48',
+ cupcap: '\u2A46',
+ cupcup: '\u2A4A',
+ cupdot: '\u228D',
+ cupor: '\u2A45',
+ cups: '\u222A\uFE00',
+ curarr: '\u21B7',
+ curarrm: '\u293C',
+ curlyeqprec: '\u22DE',
+ curlyeqsucc: '\u22DF',
+ curlyvee: '\u22CE',
+ curlywedge: '\u22CF',
+ curren: '\u00A4',
+ curvearrowleft: '\u21B6',
+ curvearrowright: '\u21B7',
+ cuvee: '\u22CE',
+ cuwed: '\u22CF',
+ cwconint: '\u2232',
+ cwint: '\u2231',
+ cylcty: '\u232D',
+ dArr: '\u21D3',
+ dHar: '\u2965',
+ dagger: '\u2020',
+ daleth: '\u2138',
+ darr: '\u2193',
+ dash: '\u2010',
+ dashv: '\u22A3',
+ dbkarow: '\u290F',
+ dblac: '\u02DD',
+ dcaron: '\u010F',
+ dcy: '\u0434',
+ dd: '\u2146',
+ ddagger: '\u2021',
+ ddarr: '\u21CA',
+ ddotseq: '\u2A77',
+ deg: '\u00B0',
+ delta: '\u03B4',
+ demptyv: '\u29B1',
+ dfisht: '\u297F',
+ dfr: '\uD835\uDD21',
+ dharl: '\u21C3',
+ dharr: '\u21C2',
+ diam: '\u22C4',
+ diamond: '\u22C4',
+ diamondsuit: '\u2666',
+ diams: '\u2666',
+ die: '\u00A8',
+ digamma: '\u03DD',
+ disin: '\u22F2',
+ div: '\u00F7',
+ divide: '\u00F7',
+ divideontimes: '\u22C7',
+ divonx: '\u22C7',
+ djcy: '\u0452',
+ dlcorn: '\u231E',
+ dlcrop: '\u230D',
+ dollar: '\u0024',
+ dopf: '\uD835\uDD55',
+ dot: '\u02D9',
+ doteq: '\u2250',
+ doteqdot: '\u2251',
+ dotminus: '\u2238',
+ dotplus: '\u2214',
+ dotsquare: '\u22A1',
+ doublebarwedge: '\u2306',
+ downarrow: '\u2193',
+ downdownarrows: '\u21CA',
+ downharpoonleft: '\u21C3',
+ downharpoonright: '\u21C2',
+ drbkarow: '\u2910',
+ drcorn: '\u231F',
+ drcrop: '\u230C',
+ dscr: '\uD835\uDCB9',
+ dscy: '\u0455',
+ dsol: '\u29F6',
+ dstrok: '\u0111',
+ dtdot: '\u22F1',
+ dtri: '\u25BF',
+ dtrif: '\u25BE',
+ duarr: '\u21F5',
+ duhar: '\u296F',
+ dwangle: '\u29A6',
+ dzcy: '\u045F',
+ dzigrarr: '\u27FF',
+ eDDot: '\u2A77',
+ eDot: '\u2251',
+ eacute: '\u00E9',
+ easter: '\u2A6E',
+ ecaron: '\u011B',
+ ecir: '\u2256',
+ ecirc: '\u00EA',
+ ecolon: '\u2255',
+ ecy: '\u044D',
+ edot: '\u0117',
+ ee: '\u2147',
+ efDot: '\u2252',
+ efr: '\uD835\uDD22',
+ eg: '\u2A9A',
+ egrave: '\u00E8',
+ egs: '\u2A96',
+ egsdot: '\u2A98',
+ el: '\u2A99',
+ elinters: '\u23E7',
+ ell: '\u2113',
+ els: '\u2A95',
+ elsdot: '\u2A97',
+ emacr: '\u0113',
+ empty: '\u2205',
+ emptyset: '\u2205',
+ emptyv: '\u2205',
+ emsp13: '\u2004',
+ emsp14: '\u2005',
+ emsp: '\u2003',
+ eng: '\u014B',
+ ensp: '\u2002',
+ eogon: '\u0119',
+ eopf: '\uD835\uDD56',
+ epar: '\u22D5',
+ eparsl: '\u29E3',
+ eplus: '\u2A71',
+ epsi: '\u03B5',
+ epsilon: '\u03B5',
+ epsiv: '\u03F5',
+ eqcirc: '\u2256',
+ eqcolon: '\u2255',
+ eqsim: '\u2242',
+ eqslantgtr: '\u2A96',
+ eqslantless: '\u2A95',
+ equals: '\u003D',
+ equest: '\u225F',
+ equiv: '\u2261',
+ equivDD: '\u2A78',
+ eqvparsl: '\u29E5',
+ erDot: '\u2253',
+ erarr: '\u2971',
+ escr: '\u212F',
+ esdot: '\u2250',
+ esim: '\u2242',
+ eta: '\u03B7',
+ eth: '\u00F0',
+ euml: '\u00EB',
+ euro: '\u20AC',
+ excl: '\u0021',
+ exist: '\u2203',
+ expectation: '\u2130',
+ exponentiale: '\u2147',
+ fallingdotseq: '\u2252',
+ fcy: '\u0444',
+ female: '\u2640',
+ ffilig: '\uFB03',
+ fflig: '\uFB00',
+ ffllig: '\uFB04',
+ ffr: '\uD835\uDD23',
+ filig: '\uFB01',
+ fjlig: '\u0066\u006A',
+ flat: '\u266D',
+ fllig: '\uFB02',
+ fltns: '\u25B1',
+ fnof: '\u0192',
+ fopf: '\uD835\uDD57',
+ forall: '\u2200',
+ fork: '\u22D4',
+ forkv: '\u2AD9',
+ fpartint: '\u2A0D',
+ frac12: '\u00BD',
+ frac13: '\u2153',
+ frac14: '\u00BC',
+ frac15: '\u2155',
+ frac16: '\u2159',
+ frac18: '\u215B',
+ frac23: '\u2154',
+ frac25: '\u2156',
+ frac34: '\u00BE',
+ frac35: '\u2157',
+ frac38: '\u215C',
+ frac45: '\u2158',
+ frac56: '\u215A',
+ frac58: '\u215D',
+ frac78: '\u215E',
+ frasl: '\u2044',
+ frown: '\u2322',
+ fscr: '\uD835\uDCBB',
+ gE: '\u2267',
+ gEl: '\u2A8C',
+ gacute: '\u01F5',
+ gamma: '\u03B3',
+ gammad: '\u03DD',
+ gap: '\u2A86',
+ gbreve: '\u011F',
+ gcirc: '\u011D',
+ gcy: '\u0433',
+ gdot: '\u0121',
+ ge: '\u2265',
+ gel: '\u22DB',
+ geq: '\u2265',
+ geqq: '\u2267',
+ geqslant: '\u2A7E',
+ ges: '\u2A7E',
+ gescc: '\u2AA9',
+ gesdot: '\u2A80',
+ gesdoto: '\u2A82',
+ gesdotol: '\u2A84',
+ gesl: '\u22DB\uFE00',
+ gesles: '\u2A94',
+ gfr: '\uD835\uDD24',
+ gg: '\u226B',
+ ggg: '\u22D9',
+ gimel: '\u2137',
+ gjcy: '\u0453',
+ gl: '\u2277',
+ glE: '\u2A92',
+ gla: '\u2AA5',
+ glj: '\u2AA4',
+ gnE: '\u2269',
+ gnap: '\u2A8A',
+ gnapprox: '\u2A8A',
+ gne: '\u2A88',
+ gneq: '\u2A88',
+ gneqq: '\u2269',
+ gnsim: '\u22E7',
+ gopf: '\uD835\uDD58',
+ grave: '\u0060',
+ gscr: '\u210A',
+ gsim: '\u2273',
+ gsime: '\u2A8E',
+ gsiml: '\u2A90',
+ gt: '\u003E',
+ gtcc: '\u2AA7',
+ gtcir: '\u2A7A',
+ gtdot: '\u22D7',
+ gtlPar: '\u2995',
+ gtquest: '\u2A7C',
+ gtrapprox: '\u2A86',
+ gtrarr: '\u2978',
+ gtrdot: '\u22D7',
+ gtreqless: '\u22DB',
+ gtreqqless: '\u2A8C',
+ gtrless: '\u2277',
+ gtrsim: '\u2273',
+ gvertneqq: '\u2269\uFE00',
+ gvnE: '\u2269\uFE00',
+ hArr: '\u21D4',
+ hairsp: '\u200A',
+ half: '\u00BD',
+ hamilt: '\u210B',
+ hardcy: '\u044A',
+ harr: '\u2194',
+ harrcir: '\u2948',
+ harrw: '\u21AD',
+ hbar: '\u210F',
+ hcirc: '\u0125',
+ hearts: '\u2665',
+ heartsuit: '\u2665',
+ hellip: '\u2026',
+ hercon: '\u22B9',
+ hfr: '\uD835\uDD25',
+ hksearow: '\u2925',
+ hkswarow: '\u2926',
+ hoarr: '\u21FF',
+ homtht: '\u223B',
+ hookleftarrow: '\u21A9',
+ hookrightarrow: '\u21AA',
+ hopf: '\uD835\uDD59',
+ horbar: '\u2015',
+ hscr: '\uD835\uDCBD',
+ hslash: '\u210F',
+ hstrok: '\u0127',
+ hybull: '\u2043',
+ hyphen: '\u2010',
+ iacute: '\u00ED',
+ ic: '\u2063',
+ icirc: '\u00EE',
+ icy: '\u0438',
+ iecy: '\u0435',
+ iexcl: '\u00A1',
+ iff: '\u21D4',
+ ifr: '\uD835\uDD26',
+ igrave: '\u00EC',
+ ii: '\u2148',
+ iiiint: '\u2A0C',
+ iiint: '\u222D',
+ iinfin: '\u29DC',
+ iiota: '\u2129',
+ ijlig: '\u0133',
+ imacr: '\u012B',
+ image: '\u2111',
+ imagline: '\u2110',
+ imagpart: '\u2111',
+ imath: '\u0131',
+ imof: '\u22B7',
+ imped: '\u01B5',
+ in: '\u2208',
+ incare: '\u2105',
+ infin: '\u221E',
+ infintie: '\u29DD',
+ inodot: '\u0131',
+ int: '\u222B',
+ intcal: '\u22BA',
+ integers: '\u2124',
+ intercal: '\u22BA',
+ intlarhk: '\u2A17',
+ intprod: '\u2A3C',
+ iocy: '\u0451',
+ iogon: '\u012F',
+ iopf: '\uD835\uDD5A',
+ iota: '\u03B9',
+ iprod: '\u2A3C',
+ iquest: '\u00BF',
+ iscr: '\uD835\uDCBE',
+ isin: '\u2208',
+ isinE: '\u22F9',
+ isindot: '\u22F5',
+ isins: '\u22F4',
+ isinsv: '\u22F3',
+ isinv: '\u2208',
+ it: '\u2062',
+ itilde: '\u0129',
+ iukcy: '\u0456',
+ iuml: '\u00EF',
+ jcirc: '\u0135',
+ jcy: '\u0439',
+ jfr: '\uD835\uDD27',
+ jmath: '\u0237',
+ jopf: '\uD835\uDD5B',
+ jscr: '\uD835\uDCBF',
+ jsercy: '\u0458',
+ jukcy: '\u0454',
+ kappa: '\u03BA',
+ kappav: '\u03F0',
+ kcedil: '\u0137',
+ kcy: '\u043A',
+ kfr: '\uD835\uDD28',
+ kgreen: '\u0138',
+ khcy: '\u0445',
+ kjcy: '\u045C',
+ kopf: '\uD835\uDD5C',
+ kscr: '\uD835\uDCC0',
+ lAarr: '\u21DA',
+ lArr: '\u21D0',
+ lAtail: '\u291B',
+ lBarr: '\u290E',
+ lE: '\u2266',
+ lEg: '\u2A8B',
+ lHar: '\u2962',
+ lacute: '\u013A',
+ laemptyv: '\u29B4',
+ lagran: '\u2112',
+ lambda: '\u03BB',
+ lang: '\u27E8',
+ langd: '\u2991',
+ langle: '\u27E8',
+ lap: '\u2A85',
+ laquo: '\u00AB',
+ larr: '\u2190',
+ larrb: '\u21E4',
+ larrbfs: '\u291F',
+ larrfs: '\u291D',
+ larrhk: '\u21A9',
+ larrlp: '\u21AB',
+ larrpl: '\u2939',
+ larrsim: '\u2973',
+ larrtl: '\u21A2',
+ lat: '\u2AAB',
+ latail: '\u2919',
+ late: '\u2AAD',
+ lates: '\u2AAD\uFE00',
+ lbarr: '\u290C',
+ lbbrk: '\u2772',
+ lbrace: '\u007B',
+ lbrack: '\u005B',
+ lbrke: '\u298B',
+ lbrksld: '\u298F',
+ lbrkslu: '\u298D',
+ lcaron: '\u013E',
+ lcedil: '\u013C',
+ lceil: '\u2308',
+ lcub: '\u007B',
+ lcy: '\u043B',
+ ldca: '\u2936',
+ ldquo: '\u201C',
+ ldquor: '\u201E',
+ ldrdhar: '\u2967',
+ ldrushar: '\u294B',
+ ldsh: '\u21B2',
+ le: '\u2264',
+ leftarrow: '\u2190',
+ leftarrowtail: '\u21A2',
+ leftharpoondown: '\u21BD',
+ leftharpoonup: '\u21BC',
+ leftleftarrows: '\u21C7',
+ leftrightarrow: '\u2194',
+ leftrightarrows: '\u21C6',
+ leftrightharpoons: '\u21CB',
+ leftrightsquigarrow: '\u21AD',
+ leftthreetimes: '\u22CB',
+ leg: '\u22DA',
+ leq: '\u2264',
+ leqq: '\u2266',
+ leqslant: '\u2A7D',
+ les: '\u2A7D',
+ lescc: '\u2AA8',
+ lesdot: '\u2A7F',
+ lesdoto: '\u2A81',
+ lesdotor: '\u2A83',
+ lesg: '\u22DA\uFE00',
+ lesges: '\u2A93',
+ lessapprox: '\u2A85',
+ lessdot: '\u22D6',
+ lesseqgtr: '\u22DA',
+ lesseqqgtr: '\u2A8B',
+ lessgtr: '\u2276',
+ lesssim: '\u2272',
+ lfisht: '\u297C',
+ lfloor: '\u230A',
+ lfr: '\uD835\uDD29',
+ lg: '\u2276',
+ lgE: '\u2A91',
+ lhard: '\u21BD',
+ lharu: '\u21BC',
+ lharul: '\u296A',
+ lhblk: '\u2584',
+ ljcy: '\u0459',
+ ll: '\u226A',
+ llarr: '\u21C7',
+ llcorner: '\u231E',
+ llhard: '\u296B',
+ lltri: '\u25FA',
+ lmidot: '\u0140',
+ lmoust: '\u23B0',
+ lmoustache: '\u23B0',
+ lnE: '\u2268',
+ lnap: '\u2A89',
+ lnapprox: '\u2A89',
+ lne: '\u2A87',
+ lneq: '\u2A87',
+ lneqq: '\u2268',
+ lnsim: '\u22E6',
+ loang: '\u27EC',
+ loarr: '\u21FD',
+ lobrk: '\u27E6',
+ longleftarrow: '\u27F5',
+ longleftrightarrow: '\u27F7',
+ longmapsto: '\u27FC',
+ longrightarrow: '\u27F6',
+ looparrowleft: '\u21AB',
+ looparrowright: '\u21AC',
+ lopar: '\u2985',
+ lopf: '\uD835\uDD5D',
+ loplus: '\u2A2D',
+ lotimes: '\u2A34',
+ lowast: '\u2217',
+ lowbar: '\u005F',
+ loz: '\u25CA',
+ lozenge: '\u25CA',
+ lozf: '\u29EB',
+ lpar: '\u0028',
+ lparlt: '\u2993',
+ lrarr: '\u21C6',
+ lrcorner: '\u231F',
+ lrhar: '\u21CB',
+ lrhard: '\u296D',
+ lrm: '\u200E',
+ lrtri: '\u22BF',
+ lsaquo: '\u2039',
+ lscr: '\uD835\uDCC1',
+ lsh: '\u21B0',
+ lsim: '\u2272',
+ lsime: '\u2A8D',
+ lsimg: '\u2A8F',
+ lsqb: '\u005B',
+ lsquo: '\u2018',
+ lsquor: '\u201A',
+ lstrok: '\u0142',
+ lt: '\u003C',
+ ltcc: '\u2AA6',
+ ltcir: '\u2A79',
+ ltdot: '\u22D6',
+ lthree: '\u22CB',
+ ltimes: '\u22C9',
+ ltlarr: '\u2976',
+ ltquest: '\u2A7B',
+ ltrPar: '\u2996',
+ ltri: '\u25C3',
+ ltrie: '\u22B4',
+ ltrif: '\u25C2',
+ lurdshar: '\u294A',
+ luruhar: '\u2966',
+ lvertneqq: '\u2268\uFE00',
+ lvnE: '\u2268\uFE00',
+ mDDot: '\u223A',
+ macr: '\u00AF',
+ male: '\u2642',
+ malt: '\u2720',
+ maltese: '\u2720',
+ map: '\u21A6',
+ mapsto: '\u21A6',
+ mapstodown: '\u21A7',
+ mapstoleft: '\u21A4',
+ mapstoup: '\u21A5',
+ marker: '\u25AE',
+ mcomma: '\u2A29',
+ mcy: '\u043C',
+ mdash: '\u2014',
+ measuredangle: '\u2221',
+ mfr: '\uD835\uDD2A',
+ mho: '\u2127',
+ micro: '\u00B5',
+ mid: '\u2223',
+ midast: '\u002A',
+ midcir: '\u2AF0',
+ middot: '\u00B7',
+ minus: '\u2212',
+ minusb: '\u229F',
+ minusd: '\u2238',
+ minusdu: '\u2A2A',
+ mlcp: '\u2ADB',
+ mldr: '\u2026',
+ mnplus: '\u2213',
+ models: '\u22A7',
+ mopf: '\uD835\uDD5E',
+ mp: '\u2213',
+ mscr: '\uD835\uDCC2',
+ mstpos: '\u223E',
+ mu: '\u03BC',
+ multimap: '\u22B8',
+ mumap: '\u22B8',
+ nGg: '\u22D9\u0338',
+ nGt: '\u226B\u20D2',
+ nGtv: '\u226B\u0338',
+ nLeftarrow: '\u21CD',
+ nLeftrightarrow: '\u21CE',
+ nLl: '\u22D8\u0338',
+ nLt: '\u226A\u20D2',
+ nLtv: '\u226A\u0338',
+ nRightarrow: '\u21CF',
+ nVDash: '\u22AF',
+ nVdash: '\u22AE',
+ nabla: '\u2207',
+ nacute: '\u0144',
+ nang: '\u2220\u20D2',
+ nap: '\u2249',
+ napE: '\u2A70\u0338',
+ napid: '\u224B\u0338',
+ napos: '\u0149',
+ napprox: '\u2249',
+ natur: '\u266E',
+ natural: '\u266E',
+ naturals: '\u2115',
+ nbsp: '\u00A0',
+ nbump: '\u224E\u0338',
+ nbumpe: '\u224F\u0338',
+ ncap: '\u2A43',
+ ncaron: '\u0148',
+ ncedil: '\u0146',
+ ncong: '\u2247',
+ ncongdot: '\u2A6D\u0338',
+ ncup: '\u2A42',
+ ncy: '\u043D',
+ ndash: '\u2013',
+ ne: '\u2260',
+ neArr: '\u21D7',
+ nearhk: '\u2924',
+ nearr: '\u2197',
+ nearrow: '\u2197',
+ nedot: '\u2250\u0338',
+ nequiv: '\u2262',
+ nesear: '\u2928',
+ nesim: '\u2242\u0338',
+ nexist: '\u2204',
+ nexists: '\u2204',
+ nfr: '\uD835\uDD2B',
+ ngE: '\u2267\u0338',
+ nge: '\u2271',
+ ngeq: '\u2271',
+ ngeqq: '\u2267\u0338',
+ ngeqslant: '\u2A7E\u0338',
+ nges: '\u2A7E\u0338',
+ ngsim: '\u2275',
+ ngt: '\u226F',
+ ngtr: '\u226F',
+ nhArr: '\u21CE',
+ nharr: '\u21AE',
+ nhpar: '\u2AF2',
+ ni: '\u220B',
+ nis: '\u22FC',
+ nisd: '\u22FA',
+ niv: '\u220B',
+ njcy: '\u045A',
+ nlArr: '\u21CD',
+ nlE: '\u2266\u0338',
+ nlarr: '\u219A',
+ nldr: '\u2025',
+ nle: '\u2270',
+ nleftarrow: '\u219A',
+ nleftrightarrow: '\u21AE',
+ nleq: '\u2270',
+ nleqq: '\u2266\u0338',
+ nleqslant: '\u2A7D\u0338',
+ nles: '\u2A7D\u0338',
+ nless: '\u226E',
+ nlsim: '\u2274',
+ nlt: '\u226E',
+ nltri: '\u22EA',
+ nltrie: '\u22EC',
+ nmid: '\u2224',
+ nopf: '\uD835\uDD5F',
+ not: '\u00AC',
+ notin: '\u2209',
+ notinE: '\u22F9\u0338',
+ notindot: '\u22F5\u0338',
+ notinva: '\u2209',
+ notinvb: '\u22F7',
+ notinvc: '\u22F6',
+ notni: '\u220C',
+ notniva: '\u220C',
+ notnivb: '\u22FE',
+ notnivc: '\u22FD',
+ npar: '\u2226',
+ nparallel: '\u2226',
+ nparsl: '\u2AFD\u20E5',
+ npart: '\u2202\u0338',
+ npolint: '\u2A14',
+ npr: '\u2280',
+ nprcue: '\u22E0',
+ npre: '\u2AAF\u0338',
+ nprec: '\u2280',
+ npreceq: '\u2AAF\u0338',
+ nrArr: '\u21CF',
+ nrarr: '\u219B',
+ nrarrc: '\u2933\u0338',
+ nrarrw: '\u219D\u0338',
+ nrightarrow: '\u219B',
+ nrtri: '\u22EB',
+ nrtrie: '\u22ED',
+ nsc: '\u2281',
+ nsccue: '\u22E1',
+ nsce: '\u2AB0\u0338',
+ nscr: '\uD835\uDCC3',
+ nshortmid: '\u2224',
+ nshortparallel: '\u2226',
+ nsim: '\u2241',
+ nsime: '\u2244',
+ nsimeq: '\u2244',
+ nsmid: '\u2224',
+ nspar: '\u2226',
+ nsqsube: '\u22E2',
+ nsqsupe: '\u22E3',
+ nsub: '\u2284',
+ nsubE: '\u2AC5\u0338',
+ nsube: '\u2288',
+ nsubset: '\u2282\u20D2',
+ nsubseteq: '\u2288',
+ nsubseteqq: '\u2AC5\u0338',
+ nsucc: '\u2281',
+ nsucceq: '\u2AB0\u0338',
+ nsup: '\u2285',
+ nsupE: '\u2AC6\u0338',
+ nsupe: '\u2289',
+ nsupset: '\u2283\u20D2',
+ nsupseteq: '\u2289',
+ nsupseteqq: '\u2AC6\u0338',
+ ntgl: '\u2279',
+ ntilde: '\u00F1',
+ ntlg: '\u2278',
+ ntriangleleft: '\u22EA',
+ ntrianglelefteq: '\u22EC',
+ ntriangleright: '\u22EB',
+ ntrianglerighteq: '\u22ED',
+ nu: '\u03BD',
+ num: '\u0023',
+ numero: '\u2116',
+ numsp: '\u2007',
+ nvDash: '\u22AD',
+ nvHarr: '\u2904',
+ nvap: '\u224D\u20D2',
+ nvdash: '\u22AC',
+ nvge: '\u2265\u20D2',
+ nvgt: '\u003E\u20D2',
+ nvinfin: '\u29DE',
+ nvlArr: '\u2902',
+ nvle: '\u2264\u20D2',
+ nvlt: '\u003C\u20D2',
+ nvltrie: '\u22B4\u20D2',
+ nvrArr: '\u2903',
+ nvrtrie: '\u22B5\u20D2',
+ nvsim: '\u223C\u20D2',
+ nwArr: '\u21D6',
+ nwarhk: '\u2923',
+ nwarr: '\u2196',
+ nwarrow: '\u2196',
+ nwnear: '\u2927',
+ oS: '\u24C8',
+ oacute: '\u00F3',
+ oast: '\u229B',
+ ocir: '\u229A',
+ ocirc: '\u00F4',
+ ocy: '\u043E',
+ odash: '\u229D',
+ odblac: '\u0151',
+ odiv: '\u2A38',
+ odot: '\u2299',
+ odsold: '\u29BC',
+ oelig: '\u0153',
+ ofcir: '\u29BF',
+ ofr: '\uD835\uDD2C',
+ ogon: '\u02DB',
+ ograve: '\u00F2',
+ ogt: '\u29C1',
+ ohbar: '\u29B5',
+ ohm: '\u03A9',
+ oint: '\u222E',
+ olarr: '\u21BA',
+ olcir: '\u29BE',
+ olcross: '\u29BB',
+ oline: '\u203E',
+ olt: '\u29C0',
+ omacr: '\u014D',
+ omega: '\u03C9',
+ omicron: '\u03BF',
+ omid: '\u29B6',
+ ominus: '\u2296',
+ oopf: '\uD835\uDD60',
+ opar: '\u29B7',
+ operp: '\u29B9',
+ oplus: '\u2295',
+ or: '\u2228',
+ orarr: '\u21BB',
+ ord: '\u2A5D',
+ order: '\u2134',
+ orderof: '\u2134',
+ ordf: '\u00AA',
+ ordm: '\u00BA',
+ origof: '\u22B6',
+ oror: '\u2A56',
+ orslope: '\u2A57',
+ orv: '\u2A5B',
+ oscr: '\u2134',
+ oslash: '\u00F8',
+ osol: '\u2298',
+ otilde: '\u00F5',
+ otimes: '\u2297',
+ otimesas: '\u2A36',
+ ouml: '\u00F6',
+ ovbar: '\u233D',
+ par: '\u2225',
+ para: '\u00B6',
+ parallel: '\u2225',
+ parsim: '\u2AF3',
+ parsl: '\u2AFD',
+ part: '\u2202',
+ pcy: '\u043F',
+ percnt: '\u0025',
+ period: '\u002E',
+ permil: '\u2030',
+ perp: '\u22A5',
+ pertenk: '\u2031',
+ pfr: '\uD835\uDD2D',
+ phi: '\u03C6',
+ phiv: '\u03D5',
+ phmmat: '\u2133',
+ phone: '\u260E',
+ pi: '\u03C0',
+ pitchfork: '\u22D4',
+ piv: '\u03D6',
+ planck: '\u210F',
+ planckh: '\u210E',
+ plankv: '\u210F',
+ plus: '\u002B',
+ plusacir: '\u2A23',
+ plusb: '\u229E',
+ pluscir: '\u2A22',
+ plusdo: '\u2214',
+ plusdu: '\u2A25',
+ pluse: '\u2A72',
+ plusmn: '\u00B1',
+ plussim: '\u2A26',
+ plustwo: '\u2A27',
+ pm: '\u00B1',
+ pointint: '\u2A15',
+ popf: '\uD835\uDD61',
+ pound: '\u00A3',
+ pr: '\u227A',
+ prE: '\u2AB3',
+ prap: '\u2AB7',
+ prcue: '\u227C',
+ pre: '\u2AAF',
+ prec: '\u227A',
+ precapprox: '\u2AB7',
+ preccurlyeq: '\u227C',
+ preceq: '\u2AAF',
+ precnapprox: '\u2AB9',
+ precneqq: '\u2AB5',
+ precnsim: '\u22E8',
+ precsim: '\u227E',
+ prime: '\u2032',
+ primes: '\u2119',
+ prnE: '\u2AB5',
+ prnap: '\u2AB9',
+ prnsim: '\u22E8',
+ prod: '\u220F',
+ profalar: '\u232E',
+ profline: '\u2312',
+ profsurf: '\u2313',
+ prop: '\u221D',
+ propto: '\u221D',
+ prsim: '\u227E',
+ prurel: '\u22B0',
+ pscr: '\uD835\uDCC5',
+ psi: '\u03C8',
+ puncsp: '\u2008',
+ qfr: '\uD835\uDD2E',
+ qint: '\u2A0C',
+ qopf: '\uD835\uDD62',
+ qprime: '\u2057',
+ qscr: '\uD835\uDCC6',
+ quaternions: '\u210D',
+ quatint: '\u2A16',
+ quest: '\u003F',
+ questeq: '\u225F',
+ quot: '\u0022',
+ rAarr: '\u21DB',
+ rArr: '\u21D2',
+ rAtail: '\u291C',
+ rBarr: '\u290F',
+ rHar: '\u2964',
+ race: '\u223D\u0331',
+ racute: '\u0155',
+ radic: '\u221A',
+ raemptyv: '\u29B3',
+ rang: '\u27E9',
+ rangd: '\u2992',
+ range: '\u29A5',
+ rangle: '\u27E9',
+ raquo: '\u00BB',
+ rarr: '\u2192',
+ rarrap: '\u2975',
+ rarrb: '\u21E5',
+ rarrbfs: '\u2920',
+ rarrc: '\u2933',
+ rarrfs: '\u291E',
+ rarrhk: '\u21AA',
+ rarrlp: '\u21AC',
+ rarrpl: '\u2945',
+ rarrsim: '\u2974',
+ rarrtl: '\u21A3',
+ rarrw: '\u219D',
+ ratail: '\u291A',
+ ratio: '\u2236',
+ rationals: '\u211A',
+ rbarr: '\u290D',
+ rbbrk: '\u2773',
+ rbrace: '\u007D',
+ rbrack: '\u005D',
+ rbrke: '\u298C',
+ rbrksld: '\u298E',
+ rbrkslu: '\u2990',
+ rcaron: '\u0159',
+ rcedil: '\u0157',
+ rceil: '\u2309',
+ rcub: '\u007D',
+ rcy: '\u0440',
+ rdca: '\u2937',
+ rdldhar: '\u2969',
+ rdquo: '\u201D',
+ rdquor: '\u201D',
+ rdsh: '\u21B3',
+ real: '\u211C',
+ realine: '\u211B',
+ realpart: '\u211C',
+ reals: '\u211D',
+ rect: '\u25AD',
+ reg: '\u00AE',
+ rfisht: '\u297D',
+ rfloor: '\u230B',
+ rfr: '\uD835\uDD2F',
+ rhard: '\u21C1',
+ rharu: '\u21C0',
+ rharul: '\u296C',
+ rho: '\u03C1',
+ rhov: '\u03F1',
+ rightarrow: '\u2192',
+ rightarrowtail: '\u21A3',
+ rightharpoondown: '\u21C1',
+ rightharpoonup: '\u21C0',
+ rightleftarrows: '\u21C4',
+ rightleftharpoons: '\u21CC',
+ rightrightarrows: '\u21C9',
+ rightsquigarrow: '\u219D',
+ rightthreetimes: '\u22CC',
+ ring: '\u02DA',
+ risingdotseq: '\u2253',
+ rlarr: '\u21C4',
+ rlhar: '\u21CC',
+ rlm: '\u200F',
+ rmoust: '\u23B1',
+ rmoustache: '\u23B1',
+ rnmid: '\u2AEE',
+ roang: '\u27ED',
+ roarr: '\u21FE',
+ robrk: '\u27E7',
+ ropar: '\u2986',
+ ropf: '\uD835\uDD63',
+ roplus: '\u2A2E',
+ rotimes: '\u2A35',
+ rpar: '\u0029',
+ rpargt: '\u2994',
+ rppolint: '\u2A12',
+ rrarr: '\u21C9',
+ rsaquo: '\u203A',
+ rscr: '\uD835\uDCC7',
+ rsh: '\u21B1',
+ rsqb: '\u005D',
+ rsquo: '\u2019',
+ rsquor: '\u2019',
+ rthree: '\u22CC',
+ rtimes: '\u22CA',
+ rtri: '\u25B9',
+ rtrie: '\u22B5',
+ rtrif: '\u25B8',
+ rtriltri: '\u29CE',
+ ruluhar: '\u2968',
+ rx: '\u211E',
+ sacute: '\u015B',
+ sbquo: '\u201A',
+ sc: '\u227B',
+ scE: '\u2AB4',
+ scap: '\u2AB8',
+ scaron: '\u0161',
+ sccue: '\u227D',
+ sce: '\u2AB0',
+ scedil: '\u015F',
+ scirc: '\u015D',
+ scnE: '\u2AB6',
+ scnap: '\u2ABA',
+ scnsim: '\u22E9',
+ scpolint: '\u2A13',
+ scsim: '\u227F',
+ scy: '\u0441',
+ sdot: '\u22C5',
+ sdotb: '\u22A1',
+ sdote: '\u2A66',
+ seArr: '\u21D8',
+ searhk: '\u2925',
+ searr: '\u2198',
+ searrow: '\u2198',
+ sect: '\u00A7',
+ semi: '\u003B',
+ seswar: '\u2929',
+ setminus: '\u2216',
+ setmn: '\u2216',
+ sext: '\u2736',
+ sfr: '\uD835\uDD30',
+ sfrown: '\u2322',
+ sharp: '\u266F',
+ shchcy: '\u0449',
+ shcy: '\u0448',
+ shortmid: '\u2223',
+ shortparallel: '\u2225',
+ shy: '\u00AD',
+ sigma: '\u03C3',
+ sigmaf: '\u03C2',
+ sigmav: '\u03C2',
+ sim: '\u223C',
+ simdot: '\u2A6A',
+ sime: '\u2243',
+ simeq: '\u2243',
+ simg: '\u2A9E',
+ simgE: '\u2AA0',
+ siml: '\u2A9D',
+ simlE: '\u2A9F',
+ simne: '\u2246',
+ simplus: '\u2A24',
+ simrarr: '\u2972',
+ slarr: '\u2190',
+ smallsetminus: '\u2216',
+ smashp: '\u2A33',
+ smeparsl: '\u29E4',
+ smid: '\u2223',
+ smile: '\u2323',
+ smt: '\u2AAA',
+ smte: '\u2AAC',
+ smtes: '\u2AAC\uFE00',
+ softcy: '\u044C',
+ sol: '\u002F',
+ solb: '\u29C4',
+ solbar: '\u233F',
+ sopf: '\uD835\uDD64',
+ spades: '\u2660',
+ spadesuit: '\u2660',
+ spar: '\u2225',
+ sqcap: '\u2293',
+ sqcaps: '\u2293\uFE00',
+ sqcup: '\u2294',
+ sqcups: '\u2294\uFE00',
+ sqsub: '\u228F',
+ sqsube: '\u2291',
+ sqsubset: '\u228F',
+ sqsubseteq: '\u2291',
+ sqsup: '\u2290',
+ sqsupe: '\u2292',
+ sqsupset: '\u2290',
+ sqsupseteq: '\u2292',
+ squ: '\u25A1',
+ square: '\u25A1',
+ squarf: '\u25AA',
+ squf: '\u25AA',
+ srarr: '\u2192',
+ sscr: '\uD835\uDCC8',
+ ssetmn: '\u2216',
+ ssmile: '\u2323',
+ sstarf: '\u22C6',
+ star: '\u2606',
+ starf: '\u2605',
+ straightepsilon: '\u03F5',
+ straightphi: '\u03D5',
+ strns: '\u00AF',
+ sub: '\u2282',
+ subE: '\u2AC5',
+ subdot: '\u2ABD',
+ sube: '\u2286',
+ subedot: '\u2AC3',
+ submult: '\u2AC1',
+ subnE: '\u2ACB',
+ subne: '\u228A',
+ subplus: '\u2ABF',
+ subrarr: '\u2979',
+ subset: '\u2282',
+ subseteq: '\u2286',
+ subseteqq: '\u2AC5',
+ subsetneq: '\u228A',
+ subsetneqq: '\u2ACB',
+ subsim: '\u2AC7',
+ subsub: '\u2AD5',
+ subsup: '\u2AD3',
+ succ: '\u227B',
+ succapprox: '\u2AB8',
+ succcurlyeq: '\u227D',
+ succeq: '\u2AB0',
+ succnapprox: '\u2ABA',
+ succneqq: '\u2AB6',
+ succnsim: '\u22E9',
+ succsim: '\u227F',
+ sum: '\u2211',
+ sung: '\u266A',
+ sup1: '\u00B9',
+ sup2: '\u00B2',
+ sup3: '\u00B3',
+ sup: '\u2283',
+ supE: '\u2AC6',
+ supdot: '\u2ABE',
+ supdsub: '\u2AD8',
+ supe: '\u2287',
+ supedot: '\u2AC4',
+ suphsol: '\u27C9',
+ suphsub: '\u2AD7',
+ suplarr: '\u297B',
+ supmult: '\u2AC2',
+ supnE: '\u2ACC',
+ supne: '\u228B',
+ supplus: '\u2AC0',
+ supset: '\u2283',
+ supseteq: '\u2287',
+ supseteqq: '\u2AC6',
+ supsetneq: '\u228B',
+ supsetneqq: '\u2ACC',
+ supsim: '\u2AC8',
+ supsub: '\u2AD4',
+ supsup: '\u2AD6',
+ swArr: '\u21D9',
+ swarhk: '\u2926',
+ swarr: '\u2199',
+ swarrow: '\u2199',
+ swnwar: '\u292A',
+ szlig: '\u00DF',
+ target: '\u2316',
+ tau: '\u03C4',
+ tbrk: '\u23B4',
+ tcaron: '\u0165',
+ tcedil: '\u0163',
+ tcy: '\u0442',
+ tdot: '\u20DB',
+ telrec: '\u2315',
+ tfr: '\uD835\uDD31',
+ there4: '\u2234',
+ therefore: '\u2234',
+ theta: '\u03B8',
+ thetasym: '\u03D1',
+ thetav: '\u03D1',
+ thickapprox: '\u2248',
+ thicksim: '\u223C',
+ thinsp: '\u2009',
+ thkap: '\u2248',
+ thksim: '\u223C',
+ thorn: '\u00FE',
+ tilde: '\u02DC',
+ times: '\u00D7',
+ timesb: '\u22A0',
+ timesbar: '\u2A31',
+ timesd: '\u2A30',
+ tint: '\u222D',
+ toea: '\u2928',
+ top: '\u22A4',
+ topbot: '\u2336',
+ topcir: '\u2AF1',
+ topf: '\uD835\uDD65',
+ topfork: '\u2ADA',
+ tosa: '\u2929',
+ tprime: '\u2034',
+ trade: '\u2122',
+ triangle: '\u25B5',
+ triangledown: '\u25BF',
+ triangleleft: '\u25C3',
+ trianglelefteq: '\u22B4',
+ triangleq: '\u225C',
+ triangleright: '\u25B9',
+ trianglerighteq: '\u22B5',
+ tridot: '\u25EC',
+ trie: '\u225C',
+ triminus: '\u2A3A',
+ triplus: '\u2A39',
+ trisb: '\u29CD',
+ tritime: '\u2A3B',
+ trpezium: '\u23E2',
+ tscr: '\uD835\uDCC9',
+ tscy: '\u0446',
+ tshcy: '\u045B',
+ tstrok: '\u0167',
+ twixt: '\u226C',
+ twoheadleftarrow: '\u219E',
+ twoheadrightarrow: '\u21A0',
+ uArr: '\u21D1',
+ uHar: '\u2963',
+ uacute: '\u00FA',
+ uarr: '\u2191',
+ ubrcy: '\u045E',
+ ubreve: '\u016D',
+ ucirc: '\u00FB',
+ ucy: '\u0443',
+ udarr: '\u21C5',
+ udblac: '\u0171',
+ udhar: '\u296E',
+ ufisht: '\u297E',
+ ufr: '\uD835\uDD32',
+ ugrave: '\u00F9',
+ uharl: '\u21BF',
+ uharr: '\u21BE',
+ uhblk: '\u2580',
+ ulcorn: '\u231C',
+ ulcorner: '\u231C',
+ ulcrop: '\u230F',
+ ultri: '\u25F8',
+ umacr: '\u016B',
+ uml: '\u00A8',
+ uogon: '\u0173',
+ uopf: '\uD835\uDD66',
+ uparrow: '\u2191',
+ updownarrow: '\u2195',
+ upharpoonleft: '\u21BF',
+ upharpoonright: '\u21BE',
+ uplus: '\u228E',
+ upsi: '\u03C5',
+ upsih: '\u03D2',
+ upsilon: '\u03C5',
+ upuparrows: '\u21C8',
+ urcorn: '\u231D',
+ urcorner: '\u231D',
+ urcrop: '\u230E',
+ uring: '\u016F',
+ urtri: '\u25F9',
+ uscr: '\uD835\uDCCA',
+ utdot: '\u22F0',
+ utilde: '\u0169',
+ utri: '\u25B5',
+ utrif: '\u25B4',
+ uuarr: '\u21C8',
+ uuml: '\u00FC',
+ uwangle: '\u29A7',
+ vArr: '\u21D5',
+ vBar: '\u2AE8',
+ vBarv: '\u2AE9',
+ vDash: '\u22A8',
+ vangrt: '\u299C',
+ varepsilon: '\u03F5',
+ varkappa: '\u03F0',
+ varnothing: '\u2205',
+ varphi: '\u03D5',
+ varpi: '\u03D6',
+ varpropto: '\u221D',
+ varr: '\u2195',
+ varrho: '\u03F1',
+ varsigma: '\u03C2',
+ varsubsetneq: '\u228A\uFE00',
+ varsubsetneqq: '\u2ACB\uFE00',
+ varsupsetneq: '\u228B\uFE00',
+ varsupsetneqq: '\u2ACC\uFE00',
+ vartheta: '\u03D1',
+ vartriangleleft: '\u22B2',
+ vartriangleright: '\u22B3',
+ vcy: '\u0432',
+ vdash: '\u22A2',
+ vee: '\u2228',
+ veebar: '\u22BB',
+ veeeq: '\u225A',
+ vellip: '\u22EE',
+ verbar: '\u007C',
+ vert: '\u007C',
+ vfr: '\uD835\uDD33',
+ vltri: '\u22B2',
+ vnsub: '\u2282\u20D2',
+ vnsup: '\u2283\u20D2',
+ vopf: '\uD835\uDD67',
+ vprop: '\u221D',
+ vrtri: '\u22B3',
+ vscr: '\uD835\uDCCB',
+ vsubnE: '\u2ACB\uFE00',
+ vsubne: '\u228A\uFE00',
+ vsupnE: '\u2ACC\uFE00',
+ vsupne: '\u228B\uFE00',
+ vzigzag: '\u299A',
+ wcirc: '\u0175',
+ wedbar: '\u2A5F',
+ wedge: '\u2227',
+ wedgeq: '\u2259',
+ weierp: '\u2118',
+ wfr: '\uD835\uDD34',
+ wopf: '\uD835\uDD68',
+ wp: '\u2118',
+ wr: '\u2240',
+ wreath: '\u2240',
+ wscr: '\uD835\uDCCC',
+ xcap: '\u22C2',
+ xcirc: '\u25EF',
+ xcup: '\u22C3',
+ xdtri: '\u25BD',
+ xfr: '\uD835\uDD35',
+ xhArr: '\u27FA',
+ xharr: '\u27F7',
+ xi: '\u03BE',
+ xlArr: '\u27F8',
+ xlarr: '\u27F5',
+ xmap: '\u27FC',
+ xnis: '\u22FB',
+ xodot: '\u2A00',
+ xopf: '\uD835\uDD69',
+ xoplus: '\u2A01',
+ xotime: '\u2A02',
+ xrArr: '\u27F9',
+ xrarr: '\u27F6',
+ xscr: '\uD835\uDCCD',
+ xsqcup: '\u2A06',
+ xuplus: '\u2A04',
+ xutri: '\u25B3',
+ xvee: '\u22C1',
+ xwedge: '\u22C0',
+ yacute: '\u00FD',
+ yacy: '\u044F',
+ ycirc: '\u0177',
+ ycy: '\u044B',
+ yen: '\u00A5',
+ yfr: '\uD835\uDD36',
+ yicy: '\u0457',
+ yopf: '\uD835\uDD6A',
+ yscr: '\uD835\uDCCE',
+ yucy: '\u044E',
+ yuml: '\u00FF',
+ zacute: '\u017A',
+ zcaron: '\u017E',
+ zcy: '\u0437',
+ zdot: '\u017C',
+ zeetrf: '\u2128',
+ zeta: '\u03B6',
+ zfr: '\uD835\uDD37',
+ zhcy: '\u0436',
+ zigrarr: '\u21DD',
+ zopf: '\uD835\uDD6B',
+ zscr: '\uD835\uDCCF',
+ zwj: '\u200D',
+ zwnj: '\u200C'
+};
+
+const decodeMap: { [Identifier: string]: number } = {
+ '0': 65533,
+ '128': 8364,
+ '130': 8218,
+ '131': 402,
+ '132': 8222,
+ '133': 8230,
+ '134': 8224,
+ '135': 8225,
+ '136': 710,
+ '137': 8240,
+ '138': 352,
+ '139': 8249,
+ '140': 338,
+ '142': 381,
+ '145': 8216,
+ '146': 8217,
+ '147': 8220,
+ '148': 8221,
+ '149': 8226,
+ '150': 8211,
+ '151': 8212,
+ '152': 732,
+ '153': 8482,
+ '154': 353,
+ '155': 8250,
+ '156': 339,
+ '158': 382,
+ '159': 376
+};
+
+// Used code from https://github.com/fb55/entities (BSD license)
+export function decodeHTMLStrict(text: string): string {
+ return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
+ if (key.charAt(1) === '#') {
+ const secondChar = key.charAt(2);
+ const codePoint =
+ secondChar === 'X' || secondChar === 'x'
+ ? parseInt(key.slice(3), 16)
+ : parseInt(key.slice(2), 10);
+ return decodeCodePoint(codePoint);
+ }
+ return entities[key.slice(1, -1)] || key;
+ });
+}
+
+function decodeCodePoint(codePoint: number): string {
+ if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+ return '\uFFFD';
+ }
+
+ if (codePoint in decodeMap) {
+ codePoint = decodeMap[codePoint];
+ }
+
+ return String.fromCodePoint(codePoint);
+}
diff --git a/node_modules/meriyah/src/lexer/identifier.ts b/node_modules/meriyah/src/lexer/identifier.ts
new file mode 100644
index 0000000..ec8a7e4
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/identifier.ts
@@ -0,0 +1,177 @@
+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.length;
+
+ 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 (context & Context.Strict) {
+ return token === Token.AwaitKeyword && (context & (Context.Module | Context.InAwaitContext)) === 0
+ ? token
+ : token === Token.StaticKeyword
+ ? Token.EscapedFutureReserved
+ : (token & Token.FutureReserved) === Token.FutureReserved
+ ? Token.EscapedFutureReserved
+ : Token.EscapedReserved;
+ }
+ 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;
+ }
+
+ return token === Token.AsyncKeyword && context & Context.AllowEscapedKeyword
+ ? Token.AnyIdentifier
+ : (token & Token.FutureReserved) === Token.FutureReserved
+ ? token
+ : token === Token.AwaitKeyword && (context & Context.InAwaitContext) === 0
+ ? token
+ : 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;
+}
diff --git a/node_modules/meriyah/src/lexer/index.ts b/node_modules/meriyah/src/lexer/index.ts
new file mode 100644
index 0000000..d86aee6
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/index.ts
@@ -0,0 +1,32 @@
+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';
diff --git a/node_modules/meriyah/src/lexer/jsx.ts b/node_modules/meriyah/src/lexer/jsx.ts
new file mode 100644
index 0000000..7b80184
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/jsx.ts
@@ -0,0 +1,126 @@
+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.token =
+ CharTypes[parser.currentChar] & CharFlags.StringLiteral
+ ? scanJSXString(parser, context)
+ : scanSingleToken(parser, context, LexerState.None);
+ return parser.token;
+}
+
+/**
+ * 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.token = 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.token = Token.JSXClose;
+ } else {
+ parser.token = Token.LessThan;
+ }
+
+ break;
+ }
+ // '{'
+ case Token.LeftBrace: {
+ advanceChar(parser);
+ parser.token = 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.token = Token.JSXText;
+ }
+ }
+
+ return parser.token;
+}
+
+/**
+ * Scans JSX identifier
+ *
+ * @param parser The parser instance
+ */
+export function scanJSXIdentifier(parser: ParserState): Token {
+ if ((parser.token & 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.token = Token.Identifier;
+ return parser.token;
+}
diff --git a/node_modules/meriyah/src/lexer/numeric.ts b/node_modules/meriyah/src/lexer/numeric.ts
new file mode 100644
index 0000000..95725bb
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/numeric.ts
@@ -0,0 +1,259 @@
+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 < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 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 < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 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 < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 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) < 1) 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);
+}
diff --git a/node_modules/meriyah/src/lexer/regexp.ts b/node_modules/meriyah/src/lexer/regexp.ts
new file mode 100644
index 0000000..4a48d50
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/regexp.ts
@@ -0,0 +1,143 @@
+import { Chars } from '../chars';
+import { Context, ParserState } from '../common';
+import { Token } from '../token';
+import { advanceChar } from './common';
+import { isIdentifierPart } from './charClassifier';
+import { report, Errors } from '../errors';
+
+/**
+ * Scans regular expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+
+export function scanRegularExpression(parser: ParserState, context: Context): Token {
+ const enum RegexState {
+ Empty = 0,
+ Escape = 0x1,
+ Class = 0x2
+ }
+ const bodyStart = parser.index;
+ // Scan: ('/' | '/=') RegularExpressionBody '/' RegularExpressionFlags
+ let preparseState = RegexState.Empty;
+
+ loop: while (true) {
+ const ch = parser.currentChar;
+ advanceChar(parser);
+
+ if (preparseState & RegexState.Escape) {
+ preparseState &= ~RegexState.Escape;
+ } else {
+ switch (ch) {
+ case Chars.Slash:
+ if (!preparseState) break loop;
+ else break;
+ case Chars.Backslash:
+ preparseState |= RegexState.Escape;
+ break;
+ case Chars.LeftBracket:
+ preparseState |= RegexState.Class;
+ break;
+ case Chars.RightBracket:
+ preparseState &= RegexState.Escape;
+ break;
+ case Chars.CarriageReturn:
+ case Chars.LineFeed:
+ case Chars.LineSeparator:
+ case Chars.ParagraphSeparator:
+ report(parser, Errors.UnterminatedRegExp);
+ default: // ignore
+ }
+ }
+
+ if (parser.index >= parser.source.length) {
+ return report(parser, Errors.UnterminatedRegExp);
+ }
+ }
+
+ const bodyEnd = parser.index - 1;
+
+ const enum RegexFlags {
+ Empty = 0b00000,
+ IgnoreCase = 0b00001,
+ Global = 0b00010,
+ Multiline = 0b00100,
+ Unicode = 0b10000,
+ Sticky = 0b01000,
+ DotAll = 0b1100
+ }
+
+ let mask = RegexFlags.Empty;
+ let char = parser.currentChar;
+
+ const { index: flagStart } = parser;
+
+ while (isIdentifierPart(char)) {
+ switch (char) {
+ case Chars.LowerG:
+ if (mask & RegexFlags.Global) report(parser, Errors.DuplicateRegExpFlag, 'g');
+ mask |= RegexFlags.Global;
+ break;
+
+ case Chars.LowerI:
+ if (mask & RegexFlags.IgnoreCase) report(parser, Errors.DuplicateRegExpFlag, 'i');
+ mask |= RegexFlags.IgnoreCase;
+ break;
+
+ case Chars.LowerM:
+ if (mask & RegexFlags.Multiline) report(parser, Errors.DuplicateRegExpFlag, 'm');
+ mask |= RegexFlags.Multiline;
+ break;
+
+ case Chars.LowerU:
+ if (mask & RegexFlags.Unicode) report(parser, Errors.DuplicateRegExpFlag, 'g');
+ mask |= RegexFlags.Unicode;
+ break;
+
+ case Chars.LowerY:
+ if (mask & RegexFlags.Sticky) report(parser, Errors.DuplicateRegExpFlag, 'y');
+ mask |= RegexFlags.Sticky;
+ break;
+
+ case Chars.LowerS:
+ if (mask & RegexFlags.DotAll) report(parser, Errors.DuplicateRegExpFlag, 's');
+ mask |= RegexFlags.DotAll;
+ break;
+
+ default:
+ report(parser, Errors.UnexpectedTokenRegExpFlag);
+ }
+
+ char = advanceChar(parser);
+ }
+
+ const flags = parser.source.slice(flagStart, parser.index);
+
+ const pattern = parser.source.slice(bodyStart, bodyEnd);
+
+ parser.tokenRegExp = { pattern, flags };
+
+ if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+
+ parser.tokenValue = validate(parser, pattern, flags);
+
+ return Token.RegularExpression;
+}
+
+/**
+ * Validates regular expressions
+ *
+ *
+ * @param state Parser instance
+ * @param context Context masks
+ * @param pattern Regexp body
+ * @param flags Regexp flags
+ */
+function validate(parser: ParserState, pattern: string, flags: string): RegExp | null | Token {
+ try {
+ return new RegExp(pattern, flags);
+ } catch (e) {
+ report(parser, Errors.UnterminatedRegExp);
+ }
+}
diff --git a/node_modules/meriyah/src/lexer/scan.ts b/node_modules/meriyah/src/lexer/scan.ts
new file mode 100644
index 0000000..25063e7
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/scan.ts
@@ -0,0 +1,655 @@
+import { Chars } from '../chars';
+import { Token } from '../token';
+import { ParserState, Context, Flags } from '../common';
+import { report, Errors } from '../errors';
+import { unicodeLookup } from '../unicode';
+import {
+ advanceChar,
+ LexerState,
+ isExoticECMAScriptWhitespace,
+ NumberKind,
+ fromCodePoint,
+ consumeLineFeed,
+ scanNewLine,
+ convertTokenType
+} from './common';
+import { skipSingleLineComment, skipMultiLineComment, skipSingleHTMLComment, CommentType } from './comments';
+import { scanRegularExpression } from './regexp';
+import { scanTemplate } from './template';
+import { scanNumber } from './numeric';
+import { scanString } from './string';
+import { scanIdentifier, scanUnicodeIdentifier, scanIdentifierSlowCase, scanPrivateIdentifier } from './identifier';
+
+/*
+ * OneChar: 40, 41, 44, 58, 59, 63, 91, 93, 123, 125, 126:
+ * '(', ')', ',', ':', ';', '?', '[', ']', '{', '}', '~'
+ * PrivateField: 35: '#',
+ * Identifier: 36, 65..90, 92, 95, 97..122: '$', 'A'..'Z', '_', '\'', 'a'..'z'
+ * Period: 46: '.'
+ * StringLiteral: 34, 39: '"', `'`
+ * NumericLiteral: 48, 49..57: '0'..'9'
+ * WhiteSpace: 9, 11, 12, 32: '\t', '\v', '\f', ' '
+ * LineFeed: 10: '\n'
+ * CarriageReturn: 13: '\r'
+ * Template: 96: '`'
+ */
+
+export const TokenLookup = [
+ /* 0 - Null */ Token.Illegal,
+ /* 1 - Start of Heading */ Token.Illegal,
+ /* 2 - Start of Text */ Token.Illegal,
+ /* 3 - End of Text */ Token.Illegal,
+ /* 4 - End of Transm. */ Token.Illegal,
+ /* 5 - Enquiry */ Token.Illegal,
+ /* 6 - Acknowledgment */ Token.Illegal,
+ /* 7 - Bell */ Token.Illegal,
+ /* 8 - Backspace */ Token.Illegal,
+ /* 9 - Horizontal Tab */ Token.WhiteSpace,
+ /* 10 - Line Feed */ Token.LineFeed,
+ /* 11 - Vertical Tab */ Token.WhiteSpace,
+ /* 12 - Form Feed */ Token.WhiteSpace,
+ /* 13 - Carriage Return */ Token.CarriageReturn,
+ /* 14 - Shift Out */ Token.Illegal,
+ /* 15 - Shift In */ Token.Illegal,
+ /* 16 - Data Line Escape */ Token.Illegal,
+ /* 17 - Device Control 1 */ Token.Illegal,
+ /* 18 - Device Control 2 */ Token.Illegal,
+ /* 19 - Device Control 3 */ Token.Illegal,
+ /* 20 - Device Control 4 */ Token.Illegal,
+ /* 21 - Negative Ack. */ Token.Illegal,
+ /* 22 - Synchronous Idle */ Token.Illegal,
+ /* 23 - End of Transmit */ Token.Illegal,
+ /* 24 - Cancel */ Token.Illegal,
+ /* 25 - End of Medium */ Token.Illegal,
+ /* 26 - Substitute */ Token.Illegal,
+ /* 27 - Escape */ Token.Illegal,
+ /* 28 - File Separator */ Token.Illegal,
+ /* 29 - Group Separator */ Token.Illegal,
+ /* 30 - Record Separator */ Token.Illegal,
+ /* 31 - Unit Separator */ Token.Illegal,
+ /* 32 - Space */ Token.WhiteSpace,
+ /* 33 - ! */ Token.Negate,
+ /* 34 - " */ Token.StringLiteral,
+ /* 35 - # */ Token.PrivateField,
+ /* 36 - $ */ Token.Identifier,
+ /* 37 - % */ Token.Modulo,
+ /* 38 - & */ Token.BitwiseAnd,
+ /* 39 - ' */ Token.StringLiteral,
+ /* 40 - ( */ Token.LeftParen,
+ /* 41 - ) */ Token.RightParen,
+ /* 42 - * */ Token.Multiply,
+ /* 43 - + */ Token.Add,
+ /* 44 - , */ Token.Comma,
+ /* 45 - - */ Token.Subtract,
+ /* 46 - . */ Token.Period,
+ /* 47 - / */ Token.Divide,
+ /* 48 - 0 */ Token.NumericLiteral,
+ /* 49 - 1 */ Token.NumericLiteral,
+ /* 50 - 2 */ Token.NumericLiteral,
+ /* 51 - 3 */ Token.NumericLiteral,
+ /* 52 - 4 */ Token.NumericLiteral,
+ /* 53 - 5 */ Token.NumericLiteral,
+ /* 54 - 6 */ Token.NumericLiteral,
+ /* 55 - 7 */ Token.NumericLiteral,
+ /* 56 - 8 */ Token.NumericLiteral,
+ /* 57 - 9 */ Token.NumericLiteral,
+ /* 58 - : */ Token.Colon,
+ /* 59 - ; */ Token.Semicolon,
+ /* 60 - < */ Token.LessThan,
+ /* 61 - = */ Token.Assign,
+ /* 62 - > */ Token.GreaterThan,
+ /* 63 - ? */ Token.QuestionMark,
+ /* 64 - @ */ Token.Decorator,
+ /* 65 - A */ Token.Identifier,
+ /* 66 - B */ Token.Identifier,
+ /* 67 - C */ Token.Identifier,
+ /* 68 - D */ Token.Identifier,
+ /* 69 - E */ Token.Identifier,
+ /* 70 - F */ Token.Identifier,
+ /* 71 - G */ Token.Identifier,
+ /* 72 - H */ Token.Identifier,
+ /* 73 - I */ Token.Identifier,
+ /* 74 - J */ Token.Identifier,
+ /* 75 - K */ Token.Identifier,
+ /* 76 - L */ Token.Identifier,
+ /* 77 - M */ Token.Identifier,
+ /* 78 - N */ Token.Identifier,
+ /* 79 - O */ Token.Identifier,
+ /* 80 - P */ Token.Identifier,
+ /* 81 - Q */ Token.Identifier,
+ /* 82 - R */ Token.Identifier,
+ /* 83 - S */ Token.Identifier,
+ /* 84 - T */ Token.Identifier,
+ /* 85 - U */ Token.Identifier,
+ /* 86 - V */ Token.Identifier,
+ /* 87 - W */ Token.Identifier,
+ /* 88 - X */ Token.Identifier,
+ /* 89 - Y */ Token.Identifier,
+ /* 90 - Z */ Token.Identifier,
+ /* 91 - [ */ Token.LeftBracket,
+ /* 92 - \ */ Token.EscapedIdentifier,
+ /* 93 - ] */ Token.RightBracket,
+ /* 94 - ^ */ Token.BitwiseXor,
+ /* 95 - _ */ Token.Identifier,
+ /* 96 - ` */ Token.Template,
+ /* 97 - a */ Token.Keyword,
+ /* 98 - b */ Token.Keyword,
+ /* 99 - c */ Token.Keyword,
+ /* 100 - d */ Token.Keyword,
+ /* 101 - e */ Token.Keyword,
+ /* 102 - f */ Token.Keyword,
+ /* 103 - g */ Token.Keyword,
+ /* 104 - h */ Token.Identifier,
+ /* 105 - i */ Token.Keyword,
+ /* 106 - j */ Token.Identifier,
+ /* 107 - k */ Token.Identifier,
+ /* 108 - l */ Token.Keyword,
+ /* 109 - m */ Token.Identifier,
+ /* 110 - n */ Token.Keyword,
+ /* 111 - o */ Token.Identifier,
+ /* 112 - p */ Token.Keyword,
+ /* 113 - q */ Token.Identifier,
+ /* 114 - r */ Token.Keyword,
+ /* 115 - s */ Token.Keyword,
+ /* 116 - t */ Token.Keyword,
+ /* 117 - u */ Token.Identifier,
+ /* 118 - v */ Token.Keyword,
+ /* 119 - w */ Token.Keyword,
+ /* 120 - x */ Token.Identifier,
+ /* 121 - y */ Token.Keyword,
+ /* 122 - z */ Token.Keyword,
+ /* 123 - { */ Token.LeftBrace,
+ /* 124 - | */ Token.BitwiseOr,
+ /* 125 - } */ Token.RightBrace,
+ /* 126 - ~ */ Token.Complement,
+ /* 127 - Delete */ Token.Illegal
+];
+
+/**
+ * Scans next token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+export function nextToken(parser: ParserState, context: Context): void {
+ parser.flags = (parser.flags | Flags.NewLine) ^ Flags.NewLine;
+ parser.startPos = parser.index;
+ parser.startColumn = parser.column;
+ parser.startLine = parser.line;
+ parser.token = scanSingleToken(parser, context, LexerState.None);
+ if (parser.onToken && parser.token !== Token.EOF) {
+ const loc = {
+ start: {
+ line: parser.linePos,
+ column: parser.colPos
+ },
+ end: {
+ line: parser.line,
+ column: parser.column
+ }
+ };
+ parser.onToken(convertTokenType(parser.token), parser.tokenPos, parser.index, loc);
+ }
+}
+
+export function scanSingleToken(parser: ParserState, context: Context, state: LexerState): Token {
+ const isStartOfLine = parser.index === 0;
+
+ const source = parser.source;
+
+ // These three are only for HTMLClose comment
+ let startPos = parser.index;
+ let startLine = parser.line;
+ let startColumn = parser.column;
+
+ while (parser.index < parser.end) {
+ parser.tokenPos = parser.index;
+ parser.colPos = parser.column;
+ parser.linePos = parser.line;
+
+ let char = parser.currentChar;
+
+ if (char <= 0x7e) {
+ const token = TokenLookup[char];
+
+ switch (token) {
+ case Token.LeftParen:
+ case Token.RightParen:
+ case Token.LeftBrace:
+ case Token.RightBrace:
+ case Token.LeftBracket:
+ case Token.RightBracket:
+ case Token.Colon:
+ case Token.Semicolon:
+ case Token.Comma:
+ case Token.Complement:
+ case Token.Decorator:
+ case Token.Illegal:
+ advanceChar(parser);
+ return token;
+
+ // Look for an identifier
+ case Token.Identifier:
+ return scanIdentifier(parser, context, /* isValidAsKeyword */ 0);
+
+ // Look for identifier or keyword
+ case Token.Keyword:
+ return scanIdentifier(parser, context, /* isValidAsKeyword */ 1);
+
+ // Look for a decimal number.
+ case Token.NumericLiteral:
+ return scanNumber(parser, context, NumberKind.Decimal | NumberKind.ValidBigIntKind);
+
+ // Look for a string literal
+ case Token.StringLiteral:
+ return scanString(parser, context, char);
+
+ // Look for a template string
+ case Token.Template:
+ return scanTemplate(parser, context);
+
+ // Look for a escaped identifier
+ case Token.EscapedIdentifier:
+ return scanUnicodeIdentifier(parser, context);
+
+ // `#` (private name)
+ case Token.PrivateField:
+ return scanPrivateIdentifier(parser);
+
+ case Token.WhiteSpace:
+ advanceChar(parser);
+ break;
+
+ case Token.CarriageReturn:
+ state |= LexerState.NewLine | LexerState.LastIsCR;
+ scanNewLine(parser);
+ break;
+
+ case Token.LineFeed:
+ consumeLineFeed(parser, state);
+ state = (state & ~LexerState.LastIsCR) | LexerState.NewLine;
+ break;
+
+ // `<`, `<=`, `<<`, `<<=`, `</`, `<!--`
+ case Token.LessThan:
+ let ch = advanceChar(parser);
+ if (parser.index < parser.end) {
+ if (ch === Chars.LessThan) {
+ if (parser.index < parser.end && advanceChar(parser) === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.ShiftLeftAssign;
+ }
+ return Token.ShiftLeft;
+ } else if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.LessThanOrEqual;
+ }
+ if (ch === Chars.Exclamation) {
+ // Treat HTML begin-comment as comment-till-end-of-line.
+ const index = parser.index + 1;
+ if (
+ index + 1 < parser.end &&
+ source.charCodeAt(index) === Chars.Hyphen &&
+ source.charCodeAt(index + 1) == Chars.Hyphen
+ ) {
+ parser.column += 3;
+ parser.currentChar = source.charCodeAt((parser.index += 3));
+ state = skipSingleHTMLComment(
+ parser,
+ source,
+ state,
+ context,
+ CommentType.HTMLOpen,
+ parser.tokenPos,
+ parser.linePos,
+ parser.colPos
+ );
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ return Token.LessThan;
+ }
+ if (ch === Chars.Slash) {
+ if ((context & Context.OptionsJSX) < 1) return Token.LessThan;
+ const index = parser.index + 1;
+
+ // Check that it's not a comment start.
+ if (index < parser.end) {
+ ch = source.charCodeAt(index);
+ if (ch === Chars.Asterisk || ch === Chars.Slash) break;
+ }
+ advanceChar(parser);
+ return Token.JSXClose;
+ }
+ }
+ return Token.LessThan;
+
+ // `=`, `==`, `===`, `=>`
+ case Token.Assign: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.EqualSign) {
+ if (advanceChar(parser) === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.StrictEqual;
+ }
+ return Token.LooseEqual;
+ }
+ if (ch === Chars.GreaterThan) {
+ advanceChar(parser);
+ return Token.Arrow;
+ }
+
+ return Token.Assign;
+ }
+
+ // `!`, `!=`, `!==`
+ case Token.Negate:
+ if (advanceChar(parser) !== Chars.EqualSign) {
+ return Token.Negate;
+ }
+ if (advanceChar(parser) !== Chars.EqualSign) {
+ return Token.LooseNotEqual;
+ }
+ advanceChar(parser);
+ return Token.StrictNotEqual;
+
+ // `%`, `%=`
+ case Token.Modulo:
+ if (advanceChar(parser) !== Chars.EqualSign) return Token.Modulo;
+ advanceChar(parser);
+ return Token.ModuloAssign;
+
+ // `*`, `**`, `*=`, `**=`
+ case Token.Multiply: {
+ advanceChar(parser);
+
+ if (parser.index >= parser.end) return Token.Multiply;
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.MultiplyAssign;
+ }
+
+ if (ch !== Chars.Asterisk) return Token.Multiply;
+
+ if (advanceChar(parser) !== Chars.EqualSign) return Token.Exponentiate;
+
+ advanceChar(parser);
+
+ return Token.ExponentiateAssign;
+ }
+
+ // `^`, `^=`
+ case Token.BitwiseXor:
+ if (advanceChar(parser) !== Chars.EqualSign) return Token.BitwiseXor;
+ advanceChar(parser);
+ return Token.BitwiseXorAssign;
+
+ // `+`, `++`, `+=`
+ case Token.Add: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.Plus) {
+ advanceChar(parser);
+ return Token.Increment;
+ }
+
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.AddAssign;
+ }
+
+ return Token.Add;
+ }
+
+ // `-`, `--`, `-=`, `-->`
+ case Token.Subtract: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.Hyphen) {
+ advanceChar(parser);
+ if ((state & LexerState.NewLine || isStartOfLine) && parser.currentChar === Chars.GreaterThan) {
+ if ((context & Context.OptionsWebCompat) === 0) report(parser, Errors.HtmlCommentInWebCompat);
+ advanceChar(parser);
+ state = skipSingleHTMLComment(
+ parser,
+ source,
+ state,
+ context,
+ CommentType.HTMLClose,
+ startPos,
+ startLine,
+ startColumn
+ );
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+
+ return Token.Decrement;
+ }
+
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.SubtractAssign;
+ }
+
+ return Token.Subtract;
+ }
+
+ // `/`, `/=`, `/>`, '/*..*/'
+ case Token.Divide: {
+ advanceChar(parser);
+ if (parser.index < parser.end) {
+ const ch = parser.currentChar;
+ if (ch === Chars.Slash) {
+ advanceChar(parser);
+ state = skipSingleLineComment(
+ parser,
+ source,
+ state,
+ CommentType.Single,
+ parser.tokenPos,
+ parser.linePos,
+ parser.colPos
+ );
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ if (ch === Chars.Asterisk) {
+ advanceChar(parser);
+ state = skipMultiLineComment(parser, source, state) as LexerState;
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ if (context & Context.AllowRegExp) {
+ return scanRegularExpression(parser, context);
+ }
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.DivideAssign;
+ }
+ }
+
+ return Token.Divide;
+ }
+
+ // `.`, `...`, `.123` (numeric literal)
+ case Token.Period:
+ const next = advanceChar(parser);
+ if (next >= Chars.Zero && next <= Chars.Nine)
+ return scanNumber(parser, context, NumberKind.Float | NumberKind.Decimal);
+ if (next === Chars.Period) {
+ const index = parser.index + 1;
+ if (index < parser.end && source.charCodeAt(index) === Chars.Period) {
+ parser.column += 2;
+ parser.currentChar = source.charCodeAt((parser.index += 2));
+ return Token.Ellipsis;
+ }
+ }
+ return Token.Period;
+
+ // `|`, `||`, `|=`, `||=`
+ case Token.BitwiseOr: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.VerticalBar) {
+ advanceChar(parser);
+
+ if (parser.currentChar === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.LogicalOrAssign;
+ }
+
+ return Token.LogicalOr;
+ }
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.BitwiseOrAssign;
+ }
+
+ return Token.BitwiseOr;
+ }
+
+ // `>`, `>=`, `>>`, `>>>`, `>>=`, `>>>=`
+ case Token.GreaterThan: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.GreaterThanOrEqual;
+ }
+
+ if (ch !== Chars.GreaterThan) return Token.GreaterThan;
+
+ advanceChar(parser);
+
+ if (parser.index < parser.end) {
+ const ch = parser.currentChar;
+
+ if (ch === Chars.GreaterThan) {
+ if (advanceChar(parser) === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.LogicalShiftRightAssign;
+ }
+ return Token.LogicalShiftRight;
+ }
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.ShiftRightAssign;
+ }
+ }
+
+ return Token.ShiftRight;
+ }
+
+ // `&`, `&&`, `&=`, `&&=`
+ case Token.BitwiseAnd: {
+ advanceChar(parser);
+
+ const ch = parser.currentChar;
+
+ if (ch === Chars.Ampersand) {
+ advanceChar(parser);
+
+ if (parser.currentChar === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.LogicalAndAssign;
+ }
+
+ return Token.LogicalAnd;
+ }
+
+ if (ch === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.BitwiseAndAssign;
+ }
+
+ return Token.BitwiseAnd;
+ }
+
+ // `?`, `??`, `?.`, `??=`
+ case Token.QuestionMark: {
+ let ch = advanceChar(parser);
+ if (ch === Chars.QuestionMark) {
+ advanceChar(parser);
+
+ if (parser.currentChar === Chars.EqualSign) {
+ advanceChar(parser);
+ return Token.CoalesceAssign;
+ }
+
+ return Token.Coalesce;
+ }
+
+ if (ch === Chars.Period) {
+ const index = parser.index + 1;
+ // Check that it's not followed by any numbers
+ if (index < parser.end) {
+ ch = source.charCodeAt(index);
+ if (!(ch >= Chars.Zero && ch <= Chars.Nine)) {
+ advanceChar(parser);
+ return Token.QuestionMarkPeriod;
+ }
+ }
+ }
+
+ return Token.QuestionMark;
+ }
+
+ default:
+ // unreachable
+ }
+ } else {
+ if ((char ^ Chars.LineSeparator) <= 1) {
+ state = (state & ~LexerState.LastIsCR) | LexerState.NewLine;
+ scanNewLine(parser);
+ continue;
+ }
+
+ if ((char & 0xfc00) === 0xd800 || ((unicodeLookup[(char >>> 5) + 34816] >>> char) & 31 & 1) !== 0) {
+ if ((char & 0xfc00) === 0xdc00) {
+ char = ((char & 0x3ff) << 10) | (char & 0x3ff) | 0x10000;
+ if (((unicodeLookup[(char >>> 5) + 0] >>> char) & 31 & 1) === 0) {
+ report(parser, Errors.IllegalCharacter, fromCodePoint(char));
+ }
+ parser.index++;
+ parser.currentChar = char;
+ }
+
+ parser.column++;
+ parser.tokenValue = '';
+ return scanIdentifierSlowCase(parser, context, /* hasEscape */ 0, /* canBeKeyword */ 0);
+ }
+
+ if (isExoticECMAScriptWhitespace(char)) {
+ advanceChar(parser);
+ continue;
+ }
+
+ // Invalid ASCII code point/unit
+ report(parser, Errors.IllegalCharacter, fromCodePoint(char));
+ }
+ }
+ return Token.EOF;
+}
diff --git a/node_modules/meriyah/src/lexer/string.ts b/node_modules/meriyah/src/lexer/string.ts
new file mode 100644
index 0000000..2519c38
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/string.ts
@@ -0,0 +1,242 @@
+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;
+
+ 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);
+
+ default:
+ }
+}
diff --git a/node_modules/meriyah/src/lexer/template.ts b/node_modules/meriyah/src/lexer/template.ts
new file mode 100644
index 0000000..0eeda59
--- /dev/null
+++ b/node_modules/meriyah/src/lexer/template.ts
@@ -0,0 +1,108 @@
+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);
+}
© Floofi Systems, Some rights reserved. Powered by cgit.