lakutata/src/lib/ioc/ParamParser.mjs

An IoC-based universal application framework.

import { createTokenizer as e, TokenizerFlags as t } from "./FunctionTokenizer.mjs";

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

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

          case "(":
            i();
            break;

          case ")":
            return o;

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

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

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

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

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

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

export { n as parseParameterList };