lakutata/src/lib/ioc/ParamParser.cjs

An IoC-based universal application framework.

"use strict";

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

const e = require("./FunctionTokenizer.cjs");

function t(t) {
    const {next: n, done: a} = e.createTokenizer(t);
    const r = [];
    let o = null;
    c();
    while (!a()) {
        switch (o.type) {
          case "class":
            s();
            if (!u()) {
                return null;
            }
            c();
            break;

          case "function":
            {
                const e = c();
                if (e.type === "ident" || e.type === "*") {
                    c();
                }
                break;
            }

          case "(":
            i();
            break;

          case ")":
            return r;

          case "ident":
            {
                const e = {
                    name: o.value,
                    optional: false
                };
                if (o.value === "async") {
                    const e = c();
                    if (e && e.type !== "=") {
                        break;
                    }
                }
                r.push(e);
                return r;
            }

          default:
            throw l();
        }
    }
    return r;
    function i() {
        let e = {
            name: "",
            optional: false
        };
        while (!a()) {
            c();
            switch (o.type) {
              case "ident":
                e.name = o.value;
                break;

              case "=":
                e.optional = true;
                break;

              case ",":
                r.push(e);
                e = {
                    name: "",
                    optional: false
                };
                break;

              case ")":
                if (e.name) {
                    r.push(e);
                }
                return;

              default:
                throw l();
            }
        }
    }
    function s() {
        while (!u() && !a()) {
            c(e.TokenizerFlags.Dumb);
        }
    }
    function u() {
        return o.type === "ident" && o.value === "constructor";
    }
    function c(t = e.TokenizerFlags.None) {
        o = n(t);
        return o;
    }
    function l() {
        return new SyntaxError(`Parsing parameter list, did not expect ${o.type} token${o.value ? ` (${o.value})` : ""}`);
    }
}

exports.parseParameterList = t;