@windrun-huaiin/third-ui 13.1.4 → 14.0.0

package/dist/node_modules/.pnpm/@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js

@@ -1,246 +0,0 @@
-'use strict';
-
-var assign = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/assign.js');
-var pickBy = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/pickBy.js');
-var forEach = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
-var map = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.js');
-var isString = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isString.js');
-var isRegExp = require('../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isRegExp.js');
-
-// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
-function tokenLabel(tokType) {
-    if (hasTokenLabel(tokType)) {
-        return tokType.LABEL;
-    }
-    else {
-        return tokType.name;
-    }
-}
-// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
-function hasTokenLabel(obj) {
-    return isString(obj.LABEL) && obj.LABEL !== "";
-}
-class AbstractProduction {
-    get definition() {
-        return this._definition;
-    }
-    set definition(value) {
-        this._definition = value;
-    }
-    constructor(_definition) {
-        this._definition = _definition;
-    }
-    accept(visitor) {
-        visitor.visit(this);
-        forEach(this.definition, (prod) => {
-            prod.accept(visitor);
-        });
-    }
-}
-class NonTerminal extends AbstractProduction {
-    constructor(options) {
-        super([]);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-    set definition(definition) {
-        // immutable
-    }
-    get definition() {
-        if (this.referencedRule !== undefined) {
-            return this.referencedRule.definition;
-        }
-        return [];
-    }
-    accept(visitor) {
-        visitor.visit(this);
-        // don't visit children of a reference, we will get cyclic infinite loops if we do so
-    }
-}
-class Rule extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.orgText = "";
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Alternative extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.ignoreAmbiguities = false;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Option extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionMandatory extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionMandatoryWithSeparator extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Repetition extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionWithSeparator extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Alternation extends AbstractProduction {
-    get definition() {
-        return this._definition;
-    }
-    set definition(value) {
-        this._definition = value;
-    }
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        this.ignoreAmbiguities = false;
-        this.hasPredicates = false;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Terminal {
-    constructor(options) {
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-    accept(visitor) {
-        visitor.visit(this);
-    }
-}
-function serializeGrammar(topRules) {
-    return map(topRules, serializeProduction);
-}
-function serializeProduction(node) {
-    function convertDefinition(definition) {
-        return map(definition, serializeProduction);
-    }
-    /* istanbul ignore else */
-    if (node instanceof NonTerminal) {
-        const serializedNonTerminal = {
-            type: "NonTerminal",
-            name: node.nonTerminalName,
-            idx: node.idx,
-        };
-        if (isString(node.label)) {
-            serializedNonTerminal.label = node.label;
-        }
-        return serializedNonTerminal;
-    }
-    else if (node instanceof Alternative) {
-        return {
-            type: "Alternative",
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Option) {
-        return {
-            type: "Option",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionMandatory) {
-        return {
-            type: "RepetitionMandatory",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionMandatoryWithSeparator) {
-        return {
-            type: "RepetitionMandatoryWithSeparator",
-            idx: node.idx,
-            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionWithSeparator) {
-        return {
-            type: "RepetitionWithSeparator",
-            idx: node.idx,
-            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Repetition) {
-        return {
-            type: "Repetition",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Alternation) {
-        return {
-            type: "Alternation",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Terminal) {
-        const serializedTerminal = {
-            type: "Terminal",
-            name: node.terminalType.name,
-            label: tokenLabel(node.terminalType),
-            idx: node.idx,
-        };
-        if (isString(node.label)) {
-            serializedTerminal.terminalLabel = node.label;
-        }
-        const pattern = node.terminalType.PATTERN;
-        if (node.terminalType.PATTERN) {
-            serializedTerminal.pattern = isRegExp(pattern)
-                ? pattern.source
-                : pattern;
-        }
-        return serializedTerminal;
-    }
-    else if (node instanceof Rule) {
-        return {
-            type: "Rule",
-            name: node.name,
-            orgText: node.orgText,
-            definition: convertDefinition(node.definition),
-        };
-        /* c8 ignore next 3 */
-    }
-    else {
-        throw Error("non exhaustive match");
-    }
-}
-
-exports.AbstractProduction = AbstractProduction;
-exports.Alternation = Alternation;
-exports.Alternative = Alternative;
-exports.NonTerminal = NonTerminal;
-exports.Option = Option;
-exports.Repetition = Repetition;
-exports.RepetitionMandatory = RepetitionMandatory;
-exports.RepetitionMandatoryWithSeparator = RepetitionMandatoryWithSeparator;
-exports.RepetitionWithSeparator = RepetitionWithSeparator;
-exports.Rule = Rule;
-exports.Terminal = Terminal;
-exports.serializeGrammar = serializeGrammar;
-exports.serializeProduction = serializeProduction;

package/dist/node_modules/.pnpm/@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs

@@ -1,232 +0,0 @@
-import assign from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/assign.mjs';
-import pickBy from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/pickBy.mjs';
-import forEach from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.mjs';
-import map from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.mjs';
-import isString from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isString.mjs';
-import isRegExp from '../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isRegExp.mjs';
-
-// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
-function tokenLabel(tokType) {
-    if (hasTokenLabel(tokType)) {
-        return tokType.LABEL;
-    }
-    else {
-        return tokType.name;
-    }
-}
-// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
-function hasTokenLabel(obj) {
-    return isString(obj.LABEL) && obj.LABEL !== "";
-}
-class AbstractProduction {
-    get definition() {
-        return this._definition;
-    }
-    set definition(value) {
-        this._definition = value;
-    }
-    constructor(_definition) {
-        this._definition = _definition;
-    }
-    accept(visitor) {
-        visitor.visit(this);
-        forEach(this.definition, (prod) => {
-            prod.accept(visitor);
-        });
-    }
-}
-class NonTerminal extends AbstractProduction {
-    constructor(options) {
-        super([]);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-    set definition(definition) {
-        // immutable
-    }
-    get definition() {
-        if (this.referencedRule !== undefined) {
-            return this.referencedRule.definition;
-        }
-        return [];
-    }
-    accept(visitor) {
-        visitor.visit(this);
-        // don't visit children of a reference, we will get cyclic infinite loops if we do so
-    }
-}
-class Rule extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.orgText = "";
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Alternative extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.ignoreAmbiguities = false;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Option extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionMandatory extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionMandatoryWithSeparator extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Repetition extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class RepetitionWithSeparator extends AbstractProduction {
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Alternation extends AbstractProduction {
-    get definition() {
-        return this._definition;
-    }
-    set definition(value) {
-        this._definition = value;
-    }
-    constructor(options) {
-        super(options.definition);
-        this.idx = 1;
-        this.ignoreAmbiguities = false;
-        this.hasPredicates = false;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-}
-class Terminal {
-    constructor(options) {
-        this.idx = 1;
-        assign(this, pickBy(options, (v) => v !== undefined));
-    }
-    accept(visitor) {
-        visitor.visit(this);
-    }
-}
-function serializeGrammar(topRules) {
-    return map(topRules, serializeProduction);
-}
-function serializeProduction(node) {
-    function convertDefinition(definition) {
-        return map(definition, serializeProduction);
-    }
-    /* istanbul ignore else */
-    if (node instanceof NonTerminal) {
-        const serializedNonTerminal = {
-            type: "NonTerminal",
-            name: node.nonTerminalName,
-            idx: node.idx,
-        };
-        if (isString(node.label)) {
-            serializedNonTerminal.label = node.label;
-        }
-        return serializedNonTerminal;
-    }
-    else if (node instanceof Alternative) {
-        return {
-            type: "Alternative",
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Option) {
-        return {
-            type: "Option",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionMandatory) {
-        return {
-            type: "RepetitionMandatory",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionMandatoryWithSeparator) {
-        return {
-            type: "RepetitionMandatoryWithSeparator",
-            idx: node.idx,
-            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof RepetitionWithSeparator) {
-        return {
-            type: "RepetitionWithSeparator",
-            idx: node.idx,
-            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Repetition) {
-        return {
-            type: "Repetition",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Alternation) {
-        return {
-            type: "Alternation",
-            idx: node.idx,
-            definition: convertDefinition(node.definition),
-        };
-    }
-    else if (node instanceof Terminal) {
-        const serializedTerminal = {
-            type: "Terminal",
-            name: node.terminalType.name,
-            label: tokenLabel(node.terminalType),
-            idx: node.idx,
-        };
-        if (isString(node.label)) {
-            serializedTerminal.terminalLabel = node.label;
-        }
-        const pattern = node.terminalType.PATTERN;
-        if (node.terminalType.PATTERN) {
-            serializedTerminal.pattern = isRegExp(pattern)
-                ? pattern.source
-                : pattern;
-        }
-        return serializedTerminal;
-    }
-    else if (node instanceof Rule) {
-        return {
-            type: "Rule",
-            name: node.name,
-            orgText: node.orgText,
-            definition: convertDefinition(node.definition),
-        };
-        /* c8 ignore next 3 */
-    }
-    else {
-        throw Error("non exhaustive match");
-    }
-}
-
-export { AbstractProduction, Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, serializeGrammar, serializeProduction };

package/dist/node_modules/.pnpm/@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/visitor.js

@@ -1,56 +0,0 @@
-'use strict';
-
-var model = require('./model.js');
-
-class GAstVisitor {
-    visit(node) {
-        const nodeAny = node;
-        switch (nodeAny.constructor) {
-            case model.NonTerminal:
-                return this.visitNonTerminal(nodeAny);
-            case model.Alternative:
-                return this.visitAlternative(nodeAny);
-            case model.Option:
-                return this.visitOption(nodeAny);
-            case model.RepetitionMandatory:
-                return this.visitRepetitionMandatory(nodeAny);
-            case model.RepetitionMandatoryWithSeparator:
-                return this.visitRepetitionMandatoryWithSeparator(nodeAny);
-            case model.RepetitionWithSeparator:
-                return this.visitRepetitionWithSeparator(nodeAny);
-            case model.Repetition:
-                return this.visitRepetition(nodeAny);
-            case model.Alternation:
-                return this.visitAlternation(nodeAny);
-            case model.Terminal:
-                return this.visitTerminal(nodeAny);
-            case model.Rule:
-                return this.visitRule(nodeAny);
-            /* c8 ignore next 2 */
-            default:
-                throw Error("non exhaustive match");
-        }
-    }
-    /* c8 ignore next */
-    visitNonTerminal(node) { }
-    /* c8 ignore next */
-    visitAlternative(node) { }
-    /* c8 ignore next */
-    visitOption(node) { }
-    /* c8 ignore next */
-    visitRepetition(node) { }
-    /* c8 ignore next */
-    visitRepetitionMandatory(node) { }
-    /* c8 ignore next 3 */
-    visitRepetitionMandatoryWithSeparator(node) { }
-    /* c8 ignore next */
-    visitRepetitionWithSeparator(node) { }
-    /* c8 ignore next */
-    visitAlternation(node) { }
-    /* c8 ignore next */
-    visitTerminal(node) { }
-    /* c8 ignore next */
-    visitRule(node) { }
-}
-
-exports.GAstVisitor = GAstVisitor;

package/dist/node_modules/.pnpm/@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/visitor.mjs

@@ -1,54 +0,0 @@
-import { Rule, Terminal, Alternation, Repetition, RepetitionWithSeparator, RepetitionMandatoryWithSeparator, RepetitionMandatory, Option, Alternative, NonTerminal } from './model.mjs';
-
-class GAstVisitor {
-    visit(node) {
-        const nodeAny = node;
-        switch (nodeAny.constructor) {
-            case NonTerminal:
-                return this.visitNonTerminal(nodeAny);
-            case Alternative:
-                return this.visitAlternative(nodeAny);
-            case Option:
-                return this.visitOption(nodeAny);
-            case RepetitionMandatory:
-                return this.visitRepetitionMandatory(nodeAny);
-            case RepetitionMandatoryWithSeparator:
-                return this.visitRepetitionMandatoryWithSeparator(nodeAny);
-            case RepetitionWithSeparator:
-                return this.visitRepetitionWithSeparator(nodeAny);
-            case Repetition:
-                return this.visitRepetition(nodeAny);
-            case Alternation:
-                return this.visitAlternation(nodeAny);
-            case Terminal:
-                return this.visitTerminal(nodeAny);
-            case Rule:
-                return this.visitRule(nodeAny);
-            /* c8 ignore next 2 */
-            default:
-                throw Error("non exhaustive match");
-        }
-    }
-    /* c8 ignore next */
-    visitNonTerminal(node) { }
-    /* c8 ignore next */
-    visitAlternative(node) { }
-    /* c8 ignore next */
-    visitOption(node) { }
-    /* c8 ignore next */
-    visitRepetition(node) { }
-    /* c8 ignore next */
-    visitRepetitionMandatory(node) { }
-    /* c8 ignore next 3 */
-    visitRepetitionMandatoryWithSeparator(node) { }
-    /* c8 ignore next */
-    visitRepetitionWithSeparator(node) { }
-    /* c8 ignore next */
-    visitAlternation(node) { }
-    /* c8 ignore next */
-    visitTerminal(node) { }
-    /* c8 ignore next */
-    visitRule(node) { }
-}
-
-export { GAstVisitor };

package/dist/node_modules/.pnpm/@chevrotain_regexp-to-ast@11.1.2/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js

@@ -1,97 +0,0 @@
-'use strict';
-
-class BaseRegExpVisitor {
-    visitChildren(node) {
-        for (const key in node) {
-            const child = node[key];
-            /* istanbul ignore else */
-            if (node.hasOwnProperty(key)) {
-                if (child.type !== undefined) {
-                    this.visit(child);
-                }
-                else if (Array.isArray(child)) {
-                    child.forEach((subChild) => {
-                        this.visit(subChild);
-                    }, this);
-                }
-            }
-        }
-    }
-    visit(node) {
-        switch (node.type) {
-            case "Pattern":
-                this.visitPattern(node);
-                break;
-            case "Flags":
-                this.visitFlags(node);
-                break;
-            case "Disjunction":
-                this.visitDisjunction(node);
-                break;
-            case "Alternative":
-                this.visitAlternative(node);
-                break;
-            case "StartAnchor":
-                this.visitStartAnchor(node);
-                break;
-            case "EndAnchor":
-                this.visitEndAnchor(node);
-                break;
-            case "WordBoundary":
-                this.visitWordBoundary(node);
-                break;
-            case "NonWordBoundary":
-                this.visitNonWordBoundary(node);
-                break;
-            case "Lookahead":
-                this.visitLookahead(node);
-                break;
-            case "NegativeLookahead":
-                this.visitNegativeLookahead(node);
-                break;
-            case "Lookbehind":
-                this.visitLookbehind(node);
-                break;
-            case "NegativeLookbehind":
-                this.visitNegativeLookbehind(node);
-                break;
-            case "Character":
-                this.visitCharacter(node);
-                break;
-            case "Set":
-                this.visitSet(node);
-                break;
-            case "Group":
-                this.visitGroup(node);
-                break;
-            case "GroupBackReference":
-                this.visitGroupBackReference(node);
-                break;
-            case "Quantifier":
-                this.visitQuantifier(node);
-                break;
-        }
-        this.visitChildren(node);
-    }
-    visitPattern(node) { }
-    visitFlags(node) { }
-    visitDisjunction(node) { }
-    visitAlternative(node) { }
-    // Assertion
-    visitStartAnchor(node) { }
-    visitEndAnchor(node) { }
-    visitWordBoundary(node) { }
-    visitNonWordBoundary(node) { }
-    visitLookahead(node) { }
-    visitNegativeLookahead(node) { }
-    visitLookbehind(node) { }
-    visitNegativeLookbehind(node) { }
-    // atoms
-    visitCharacter(node) { }
-    visitSet(node) { }
-    visitGroup(node) { }
-    visitGroupBackReference(node) { }
-    visitQuantifier(node) { }
-}
-
-exports.BaseRegExpVisitor = BaseRegExpVisitor;