lakutata/src/lib/ioc/FunctionTokenizer.cjs

An IoC-based universal application framework.

"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

exports.TokenizerFlags = void 0;

(function(t) {
    t[t["None"] = 0] = "None";
    t[t["Dumb"] = 1] = "Dumb";
})(exports.TokenizerFlags || (exports.TokenizerFlags = {}));

function t(t) {
    const r = t.length;
    let c = 0;
    let o = "EOF";
    let s = "";
    let a = exports.TokenizerFlags.None;
    let f = 0;
    let l = 0;
    return {
        next: h,
        done: T
    };
    function h(t = exports.TokenizerFlags.None) {
        a = t;
        F();
        return z();
    }
    function F() {
        s = "";
        o = "EOF";
        while (true) {
            if (c >= r) {
                return o = "EOF";
            }
            const n = t.charAt(c);
            if (e(n)) {
                c++;
                continue;
            }
            switch (n) {
              case "(":
                c++;
                f++;
                return o = n;

              case ")":
                c++;
                l++;
                return o = n;

              case "*":
                c++;
                return o = n;

              case ",":
                c++;
                return o = n;

              case "=":
                c++;
                if ((a & exports.TokenizerFlags.Dumb) === 0) {
                    g();
                }
                return o = n;

              case "/":
                {
                    c++;
                    const e = t.charAt(c);
                    if (e === "/") {
                        p((t => t === "\n"), true);
                        c++;
                    }
                    if (e === "*") {
                        p((e => {
                            const n = t.charAt(c + 1);
                            return e === "*" && n === "/";
                        }), true);
                        c++;
                    }
                    continue;
                }

              default:
                if (u(n)) {
                    A();
                    return o;
                }
                c++;
            }
        }
    }
    function A() {
        const e = t.charAt(c);
        const n = ++c;
        while (i(t.charAt(c))) {
            c++;
        }
        s = "" + e + t.substring(n, c);
        o = s === "function" || s === "class" ? s : "ident";
        if (o !== "ident") {
            s = "";
        }
        return s;
    }
    function g() {
        p((t => {
            const e = f === l + 1;
            if (t === "," && e) {
                return true;
            }
            if (t === "(") {
                f++;
                return false;
            }
            if (t === ")") {
                l++;
                if (e) {
                    return true;
                }
            }
            return false;
        }));
    }
    function p(r, u = false) {
        while (c < t.length) {
            const i = t.charAt(c);
            if (r(i)) {
                return;
            }
            if (!u) {
                if (e(i)) {
                    c++;
                    continue;
                }
                if (n(i)) {
                    x();
                    continue;
                }
            }
            c++;
        }
    }
    function x() {
        const e = t.charAt(c);
        c++;
        while (c < t.length) {
            const n = t.charAt(c);
            const r = t.charAt(c - 1);
            if (n === e && r !== "\\") {
                c++;
                return;
            }
            if (e === "`") {
                const e = t.charAt(c + 1);
                if (e === "$") {
                    const e = t.charAt(c + 2);
                    if (e === "{") {
                        c = c + 2;
                        p((t => t === "}"));
                    }
                }
            }
            c++;
        }
    }
    function z() {
        if (s) {
            return {
                value: s,
                type: o
            };
        }
        return {
            type: o
        };
    }
    function T() {
        return o === "EOF";
    }
}

function e(t) {
    switch (t) {
      case "\r":
      case "\n":
      case " ":
        return true;
    }
    return false;
}

function n(t) {
    switch (t) {
      case "'":
      case '"':
      case "`":
        return true;
    }
    return false;
}

const r = /^[_$a-zA-Z\xA0-\uFFFF]$/;

const c = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;

function u(t) {
    return r.test(t);
}

function i(t) {
    return c.test(t);
}

exports.createTokenizer = t;