Website Structure

Frontend-Learner/node_modules/eslint-plugin-regexp/dist/utils/string-literal-parser/tokenizer.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokenizer = void 0;
+const CP_BACK_SLASH = "\\".codePointAt(0);
+const CP_BACKTICK = "`".codePointAt(0);
+const CP_CR = "\r".codePointAt(0);
+const CP_LF = "\n".codePointAt(0);
+const CP_OPENING_BRACE = "{".codePointAt(0);
+const CP_a = "a".codePointAt(0);
+const CP_A = "A".codePointAt(0);
+const CP_n = "n".codePointAt(0);
+const CP_r = "r".codePointAt(0);
+const CP_t = "t".codePointAt(0);
+const CP_b = "b".codePointAt(0);
+const CP_v = "v".codePointAt(0);
+const CP_f = "f".codePointAt(0);
+const CP_u = "u".codePointAt(0);
+const CP_x = "x".codePointAt(0);
+const CP_0 = "0".codePointAt(0);
+const CP_7 = "7".codePointAt(0);
+const CP_8 = "8".codePointAt(0);
+const CP_9 = "9".codePointAt(0);
+class Tokenizer {
+    constructor(source, options) {
+        var _a;
+        this.source = source;
+        this.pos = options.start;
+        this.end = (_a = options.end) !== null && _a !== void 0 ? _a : null;
+        this.ecmaVersion = options.ecmaVersion;
+    }
+    *parseTokens(quote) {
+        var _a;
+        const inTemplate = quote === CP_BACKTICK;
+        const endIndex = (_a = this.end) !== null && _a !== void 0 ? _a : this.source.length;
+        while (this.pos < endIndex) {
+            const start = this.pos;
+            const cp = this.source.codePointAt(start);
+            if (cp == null) {
+                throw new Error("Unterminated string constant");
+            }
+            this.pos = inc(start, cp);
+            if (cp === quote)
+                break;
+            if (cp === CP_BACK_SLASH) {
+                const { value, kind } = this.readEscape(inTemplate);
+                yield {
+                    type: "EscapeToken",
+                    kind,
+                    value,
+                    range: [start, this.pos],
+                };
+            }
+            else if (cp === CP_CR || cp === CP_LF) {
+                if (inTemplate) {
+                    if (cp === CP_CR &&
+                        this.source.codePointAt(this.pos) === CP_LF) {
+                        this.pos++;
+                    }
+                    yield {
+                        type: "CharacterToken",
+                        value: "\n",
+                        range: [start, this.pos],
+                    };
+                }
+                else {
+                    throw new Error("Unterminated string constant");
+                }
+            }
+            else {
+                if (this.ecmaVersion >= 2019 &&
+                    (cp === 0x2028 || cp === 0x2029) &&
+                    !inTemplate) {
+                    throw new Error("Unterminated string constant");
+                }
+                yield {
+                    type: "CharacterToken",
+                    value: String.fromCodePoint(cp),
+                    range: [start, this.pos],
+                };
+            }
+        }
+    }
+    readEscape(inTemplate) {
+        const cp = this.source.codePointAt(this.pos);
+        if (cp == null) {
+            throw new Error("Invalid or unexpected token");
+        }
+        this.pos = inc(this.pos, cp);
+        switch (cp) {
+            case CP_n:
+                return { value: "\n", kind: "special" };
+            case CP_r:
+                return { value: "\r", kind: "special" };
+            case CP_t:
+                return { value: "\t", kind: "special" };
+            case CP_b:
+                return { value: "\b", kind: "special" };
+            case CP_v:
+                return { value: "\v", kind: "special" };
+            case CP_f:
+                return { value: "\f", kind: "special" };
+            case CP_CR:
+                if (this.source.codePointAt(this.pos) === CP_LF) {
+                    this.pos++;
+                }
+            case CP_LF:
+                return { value: "", kind: "eol" };
+            case CP_x:
+                return {
+                    value: String.fromCodePoint(this.readHex(2)),
+                    kind: "hex",
+                };
+            case CP_u:
+                return {
+                    value: String.fromCodePoint(this.readUnicode()),
+                    kind: "unicode",
+                };
+            default:
+                if (CP_0 <= cp && cp <= CP_7) {
+                    let octalStr = /^[0-7]+/u.exec(this.source.slice(this.pos - 1, this.pos + 2))[0];
+                    let octal = parseInt(octalStr, 8);
+                    if (octal > 255) {
+                        octalStr = octalStr.slice(0, -1);
+                        octal = parseInt(octalStr, 8);
+                    }
+                    this.pos += octalStr.length - 1;
+                    const nextCp = this.source.codePointAt(this.pos);
+                    if ((octalStr !== "0" ||
+                        nextCp === CP_8 ||
+                        nextCp === CP_9) &&
+                        inTemplate) {
+                        throw new Error("Octal literal in template string");
+                    }
+                    return {
+                        value: String.fromCodePoint(octal),
+                        kind: "octal",
+                    };
+                }
+                return {
+                    value: String.fromCodePoint(cp),
+                    kind: "char",
+                };
+        }
+    }
+    readUnicode() {
+        const cp = this.source.codePointAt(this.pos);
+        if (cp === CP_OPENING_BRACE) {
+            if (this.ecmaVersion < 2015) {
+                throw new Error(`Unexpected character '${String.fromCodePoint(cp)}'`);
+            }
+            this.pos++;
+            const endIndex = this.source.indexOf("}", this.pos);
+            if (endIndex < 0) {
+                throw new Error("Invalid Unicode escape sequence");
+            }
+            const code = this.readHex(endIndex - this.pos);
+            this.pos++;
+            if (code > 0x10ffff) {
+                throw new Error("Code point out of bounds");
+            }
+            return code;
+        }
+        return this.readHex(4);
+    }
+    readHex(length) {
+        let total = 0;
+        for (let i = 0; i < length; i++, this.pos++) {
+            const cp = this.source.codePointAt(this.pos);
+            if (cp == null) {
+                throw new Error(`Invalid hexadecimal escape sequence`);
+            }
+            let val;
+            if (CP_a <= cp) {
+                val = cp - CP_a + 10;
+            }
+            else if (CP_A <= cp) {
+                val = cp - CP_A + 10;
+            }
+            else if (CP_0 <= cp && cp <= CP_9) {
+                val = cp - CP_0;
+            }
+            else {
+                throw new Error(`Invalid hexadecimal escape sequence`);
+            }
+            if (val >= 16) {
+                throw new Error(`Invalid hexadecimal escape sequence`);
+            }
+            total = total * 16 + val;
+        }
+        return total;
+    }
+}
+exports.Tokenizer = Tokenizer;
+function inc(pos, cp) {
+    return pos + (cp >= 0x10000 ? 2 : 1);
+}