@windrun-huaiin/third-ui 13.1.4 → 13.1.5

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.1.2/node_modules/chevrotain-allstar/lib/atn.mjs

@@ -1,409 +0,0 @@
-import map from '../../../../lodash-es@4.17.23/node_modules/lodash-es/map.mjs';
-import filter from '../../../../lodash-es@4.17.23/node_modules/lodash-es/filter.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.mjs';
-import { Terminal, NonTerminal, Alternation, Option, Repetition, RepetitionWithSeparator, RepetitionMandatory, RepetitionMandatoryWithSeparator } from '../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs';
-import '../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs';
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-function buildATNKey(rule, type, occurrence) {
-    return `${rule.name}_${type}_${occurrence}`;
-}
-const ATN_BASIC = 1;
-const ATN_RULE_START = 2;
-const ATN_PLUS_BLOCK_START = 4;
-const ATN_STAR_BLOCK_START = 5;
-const ATN_RULE_STOP = 7;
-const ATN_BLOCK_END = 8;
-const ATN_STAR_LOOP_BACK = 9;
-const ATN_STAR_LOOP_ENTRY = 10;
-const ATN_PLUS_LOOP_BACK = 11;
-const ATN_LOOP_END = 12;
-class AbstractTransition {
-    constructor(target) {
-        this.target = target;
-    }
-    isEpsilon() {
-        return false;
-    }
-}
-class AtomTransition extends AbstractTransition {
-    constructor(target, tokenType) {
-        super(target);
-        this.tokenType = tokenType;
-    }
-}
-class EpsilonTransition extends AbstractTransition {
-    constructor(target) {
-        super(target);
-    }
-    isEpsilon() {
-        return true;
-    }
-}
-class RuleTransition extends AbstractTransition {
-    constructor(ruleStart, rule, followState) {
-        super(ruleStart);
-        this.rule = rule;
-        this.followState = followState;
-    }
-    isEpsilon() {
-        return true;
-    }
-}
-function createATN(rules) {
-    const atn = {
-        decisionMap: {},
-        decisionStates: [],
-        ruleToStartState: new Map(),
-        ruleToStopState: new Map(),
-        states: []
-    };
-    createRuleStartAndStopATNStates(atn, rules);
-    const ruleLength = rules.length;
-    for (let i = 0; i < ruleLength; i++) {
-        const rule = rules[i];
-        const ruleBlock = block(atn, rule, rule);
-        if (ruleBlock === undefined) {
-            continue;
-        }
-        buildRuleHandle(atn, rule, ruleBlock);
-    }
-    return atn;
-}
-function createRuleStartAndStopATNStates(atn, rules) {
-    const ruleLength = rules.length;
-    for (let i = 0; i < ruleLength; i++) {
-        const rule = rules[i];
-        const start = newState(atn, rule, undefined, {
-            type: ATN_RULE_START
-        });
-        const stop = newState(atn, rule, undefined, {
-            type: ATN_RULE_STOP
-        });
-        start.stop = stop;
-        atn.ruleToStartState.set(rule, start);
-        atn.ruleToStopState.set(rule, stop);
-    }
-}
-function atom(atn, rule, production) {
-    if (production instanceof Terminal) {
-        return tokenRef(atn, rule, production.terminalType, production);
-    }
-    else if (production instanceof NonTerminal) {
-        return ruleRef(atn, rule, production);
-    }
-    else if (production instanceof Alternation) {
-        return alternation(atn, rule, production);
-    }
-    else if (production instanceof Option) {
-        return option(atn, rule, production);
-    }
-    else if (production instanceof Repetition) {
-        return repetition(atn, rule, production);
-    }
-    else if (production instanceof RepetitionWithSeparator) {
-        return repetitionSep(atn, rule, production);
-    }
-    else if (production instanceof RepetitionMandatory) {
-        return repetitionMandatory(atn, rule, production);
-    }
-    else if (production instanceof RepetitionMandatoryWithSeparator) {
-        return repetitionMandatorySep(atn, rule, production);
-    }
-    else {
-        return block(atn, rule, production);
-    }
-}
-function repetition(atn, rule, repetition) {
-    const starState = newState(atn, rule, repetition, {
-        type: ATN_STAR_BLOCK_START
-    });
-    defineDecisionState(atn, starState);
-    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
-    return star(atn, rule, repetition, handle);
-}
-function repetitionSep(atn, rule, repetition) {
-    const starState = newState(atn, rule, repetition, {
-        type: ATN_STAR_BLOCK_START
-    });
-    defineDecisionState(atn, starState);
-    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
-    const sep = tokenRef(atn, rule, repetition.separator, repetition);
-    return star(atn, rule, repetition, handle, sep);
-}
-function repetitionMandatory(atn, rule, repetition) {
-    const plusState = newState(atn, rule, repetition, {
-        type: ATN_PLUS_BLOCK_START
-    });
-    defineDecisionState(atn, plusState);
-    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
-    return plus(atn, rule, repetition, handle);
-}
-function repetitionMandatorySep(atn, rule, repetition) {
-    const plusState = newState(atn, rule, repetition, {
-        type: ATN_PLUS_BLOCK_START
-    });
-    defineDecisionState(atn, plusState);
-    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
-    const sep = tokenRef(atn, rule, repetition.separator, repetition);
-    return plus(atn, rule, repetition, handle, sep);
-}
-function alternation(atn, rule, alternation) {
-    const start = newState(atn, rule, alternation, {
-        type: ATN_BASIC
-    });
-    defineDecisionState(atn, start);
-    const alts = map(alternation.definition, (e) => atom(atn, rule, e));
-    const handle = makeAlts(atn, rule, start, alternation, ...alts);
-    return handle;
-}
-function option(atn, rule, option) {
-    const start = newState(atn, rule, option, {
-        type: ATN_BASIC
-    });
-    defineDecisionState(atn, start);
-    const handle = makeAlts(atn, rule, start, option, block(atn, rule, option));
-    return optional(atn, rule, option, handle);
-}
-function block(atn, rule, block) {
-    const handles = filter(map(block.definition, (e) => atom(atn, rule, e)), (e) => e !== undefined);
-    if (handles.length === 1) {
-        return handles[0];
-    }
-    else if (handles.length === 0) {
-        return undefined;
-    }
-    else {
-        return makeBlock(atn, handles);
-    }
-}
-function plus(atn, rule, plus, handle, sep) {
-    const blkStart = handle.left;
-    const blkEnd = handle.right;
-    const loop = newState(atn, rule, plus, {
-        type: ATN_PLUS_LOOP_BACK
-    });
-    defineDecisionState(atn, loop);
-    const end = newState(atn, rule, plus, {
-        type: ATN_LOOP_END
-    });
-    blkStart.loopback = loop;
-    end.loopback = loop;
-    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionMandatoryWithSeparator' : 'RepetitionMandatory', plus.idx)] = loop;
-    epsilon(blkEnd, loop); // block can see loop back
-    // Depending on whether we have a separator we put the exit transition at index 1 or 0
-    // This influences the chosen option in the lookahead DFA
-    if (sep === undefined) {
-        epsilon(loop, blkStart); // loop back to start
-        epsilon(loop, end); // exit
-    }
-    else {
-        epsilon(loop, end); // exit
-        // loop back to start with separator
-        epsilon(loop, sep.left);
-        epsilon(sep.right, blkStart);
-    }
-    return {
-        left: blkStart,
-        right: end
-    };
-}
-function star(atn, rule, star, handle, sep) {
-    const start = handle.left;
-    const end = handle.right;
-    const entry = newState(atn, rule, star, {
-        type: ATN_STAR_LOOP_ENTRY
-    });
-    defineDecisionState(atn, entry);
-    const loopEnd = newState(atn, rule, star, {
-        type: ATN_LOOP_END
-    });
-    const loop = newState(atn, rule, star, {
-        type: ATN_STAR_LOOP_BACK
-    });
-    entry.loopback = loop;
-    loopEnd.loopback = loop;
-    epsilon(entry, start); // loop enter edge (alt 2)
-    epsilon(entry, loopEnd); // bypass loop edge (alt 1)
-    epsilon(end, loop); // block end hits loop back
-    if (sep !== undefined) {
-        epsilon(loop, loopEnd); // end loop
-        // loop back to start of handle using separator
-        epsilon(loop, sep.left);
-        epsilon(sep.right, start);
-    }
-    else {
-        epsilon(loop, entry); // loop back to entry/exit decision
-    }
-    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionWithSeparator' : 'Repetition', star.idx)] = entry;
-    return {
-        left: entry,
-        right: loopEnd
-    };
-}
-function optional(atn, rule, optional, handle) {
-    const start = handle.left;
-    const end = handle.right;
-    epsilon(start, end);
-    atn.decisionMap[buildATNKey(rule, 'Option', optional.idx)] = start;
-    return handle;
-}
-function defineDecisionState(atn, state) {
-    atn.decisionStates.push(state);
-    state.decision = atn.decisionStates.length - 1;
-    return state.decision;
-}
-function makeAlts(atn, rule, start, production, ...alts) {
-    const end = newState(atn, rule, production, {
-        type: ATN_BLOCK_END,
-        start
-    });
-    start.end = end;
-    for (const alt of alts) {
-        if (alt !== undefined) {
-            // hook alts up to decision block
-            epsilon(start, alt.left);
-            epsilon(alt.right, end);
-        }
-        else {
-            epsilon(start, end);
-        }
-    }
-    const handle = {
-        left: start,
-        right: end
-    };
-    atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;
-    return handle;
-}
-function getProdType(production) {
-    if (production instanceof Alternation) {
-        return 'Alternation';
-    }
-    else if (production instanceof Option) {
-        return 'Option';
-    }
-    else if (production instanceof Repetition) {
-        return 'Repetition';
-    }
-    else if (production instanceof RepetitionWithSeparator) {
-        return 'RepetitionWithSeparator';
-    }
-    else if (production instanceof RepetitionMandatory) {
-        return 'RepetitionMandatory';
-    }
-    else if (production instanceof RepetitionMandatoryWithSeparator) {
-        return 'RepetitionMandatoryWithSeparator';
-    }
-    else {
-        throw new Error('Invalid production type encountered');
-    }
-}
-function makeBlock(atn, alts) {
-    const altsLength = alts.length;
-    for (let i = 0; i < altsLength - 1; i++) {
-        const handle = alts[i];
-        let transition;
-        if (handle.left.transitions.length === 1) {
-            transition = handle.left.transitions[0];
-        }
-        const isRuleTransition = transition instanceof RuleTransition;
-        const ruleTransition = transition;
-        const next = alts[i + 1].left;
-        if (handle.left.type === ATN_BASIC &&
-            handle.right.type === ATN_BASIC &&
-            transition !== undefined &&
-            ((isRuleTransition && ruleTransition.followState === handle.right) ||
-                transition.target === handle.right)) {
-            // we can avoid epsilon edge to next element
-            if (isRuleTransition) {
-                ruleTransition.followState = next;
-            }
-            else {
-                transition.target = next;
-            }
-            removeState(atn, handle.right); // we skipped over this state
-        }
-        else {
-            // need epsilon if previous block's right end node is complex
-            epsilon(handle.right, next);
-        }
-    }
-    const first = alts[0];
-    const last = alts[altsLength - 1];
-    return {
-        left: first.left,
-        right: last.right
-    };
-}
-function tokenRef(atn, rule, tokenType, production) {
-    const left = newState(atn, rule, production, {
-        type: ATN_BASIC
-    });
-    const right = newState(atn, rule, production, {
-        type: ATN_BASIC
-    });
-    addTransition(left, new AtomTransition(right, tokenType));
-    return {
-        left,
-        right
-    };
-}
-function ruleRef(atn, currentRule, nonTerminal) {
-    const rule = nonTerminal.referencedRule;
-    const start = atn.ruleToStartState.get(rule);
-    const left = newState(atn, currentRule, nonTerminal, {
-        type: ATN_BASIC
-    });
-    const right = newState(atn, currentRule, nonTerminal, {
-        type: ATN_BASIC
-    });
-    const call = new RuleTransition(start, rule, right);
-    addTransition(left, call);
-    return {
-        left,
-        right
-    };
-}
-function buildRuleHandle(atn, rule, block) {
-    const start = atn.ruleToStartState.get(rule);
-    epsilon(start, block.left);
-    const stop = atn.ruleToStopState.get(rule);
-    epsilon(block.right, stop);
-    const handle = {
-        left: start,
-        right: stop
-    };
-    return handle;
-}
-function epsilon(a, b) {
-    const transition = new EpsilonTransition(b);
-    addTransition(a, transition);
-}
-function newState(atn, rule, production, partial) {
-    const t = Object.assign({ atn,
-        production, epsilonOnlyTransitions: false, rule, transitions: [], nextTokenWithinRule: [], stateNumber: atn.states.length }, partial);
-    atn.states.push(t);
-    return t;
-}
-function addTransition(state, transition) {
-    // A single ATN state can only contain epsilon transitions or non-epsilon transitions
-    // Because they are never mixed, only setting the property for the first transition is fine
-    if (state.transitions.length === 0) {
-        state.epsilonOnlyTransitions = transition.isEpsilon();
-    }
-    state.transitions.push(transition);
-}
-function removeState(atn, state) {
-    atn.states.splice(atn.states.indexOf(state), 1);
-}
-
-export { ATN_BASIC, ATN_BLOCK_END, ATN_LOOP_END, ATN_PLUS_BLOCK_START, ATN_PLUS_LOOP_BACK, ATN_RULE_START, ATN_RULE_STOP, ATN_STAR_BLOCK_START, ATN_STAR_LOOP_BACK, ATN_STAR_LOOP_ENTRY, AbstractTransition, AtomTransition, EpsilonTransition, RuleTransition, buildATNKey, createATN };

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.1.2/node_modules/chevrotain-allstar/lib/dfa.js

@@ -1,52 +0,0 @@
-'use strict';
-
-var map = require('../../../../lodash-es@4.17.23/node_modules/lodash-es/map.js');
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-const DFA_ERROR = {};
-class ATNConfigSet {
-    constructor() {
-        this.map = {};
-        this.configs = [];
-    }
-    get size() {
-        return this.configs.length;
-    }
-    finalize() {
-        // Empties the map to free up memory
-        this.map = {};
-    }
-    add(config) {
-        const key = getATNConfigKey(config);
-        // Only add configs which don't exist in our map already
-        // While this does not influence the actual algorithm, adding them anyway would massively increase memory consumption
-        if (!(key in this.map)) {
-            this.map[key] = this.configs.length;
-            this.configs.push(config);
-        }
-    }
-    get elements() {
-        return this.configs;
-    }
-    get alts() {
-        return map(this.configs, (e) => e.alt);
-    }
-    get key() {
-        let value = "";
-        for (const k in this.map) {
-            value += k + ":";
-        }
-        return value;
-    }
-}
-function getATNConfigKey(config, alt = true) {
-    return `${alt ? `a${config.alt}` : ""}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join("_")}`;
-}
-
-exports.ATNConfigSet = ATNConfigSet;
-exports.DFA_ERROR = DFA_ERROR;
-exports.getATNConfigKey = getATNConfigKey;

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.1.2/node_modules/chevrotain-allstar/lib/dfa.mjs

@@ -1,48 +0,0 @@
-import map from '../../../../lodash-es@4.17.23/node_modules/lodash-es/map.mjs';
-
-/******************************************************************************
- * Copyright 2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-const DFA_ERROR = {};
-class ATNConfigSet {
-    constructor() {
-        this.map = {};
-        this.configs = [];
-    }
-    get size() {
-        return this.configs.length;
-    }
-    finalize() {
-        // Empties the map to free up memory
-        this.map = {};
-    }
-    add(config) {
-        const key = getATNConfigKey(config);
-        // Only add configs which don't exist in our map already
-        // While this does not influence the actual algorithm, adding them anyway would massively increase memory consumption
-        if (!(key in this.map)) {
-            this.map[key] = this.configs.length;
-            this.configs.push(config);
-        }
-    }
-    get elements() {
-        return this.configs;
-    }
-    get alts() {
-        return map(this.configs, (e) => e.alt);
-    }
-    get key() {
-        let value = "";
-        for (const k in this.map) {
-            value += k + ":";
-        }
-        return value;
-    }
-}
-function getATNConfigKey(config, alt = true) {
-    return `${alt ? `a${config.alt}` : ""}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join("_")}`;
-}
-
-export { ATNConfigSet, DFA_ERROR, getATNConfigKey };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/lang/lang_extensions.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const NAME = "name";
-function defineNameProp(obj, nameValue) {
-    Object.defineProperty(obj, NAME, {
-        enumerable: false,
-        configurable: true,
-        writable: false,
-        value: nameValue,
-    });
-}
-
-exports.defineNameProp = defineNameProp;

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/lang/lang_extensions.mjs

@@ -1,11 +0,0 @@
-const NAME = "name";
-function defineNameProp(obj, nameValue) {
-    Object.defineProperty(obj, NAME, {
-        enumerable: false,
-        configurable: true,
-        writable: false,
-        value: nameValue,
-    });
-}
-
-export { defineNameProp };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/constants.js

@@ -1,6 +0,0 @@
-'use strict';
-
-// TODO: can this be removed? where is it used?
-const IN = "_~IN~_";
-
-exports.IN = IN;

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/constants.mjs

@@ -1,4 +0,0 @@
-// TODO: can this be removed? where is it used?
-const IN = "_~IN~_";
-
-export { IN };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/cst/cst.js

@@ -1,77 +0,0 @@
-'use strict';
-
-/**
- * This nodeLocation tracking is not efficient and should only be used
- * when error recovery is enabled or the Token Vector contains virtual Tokens
- * (e.g, Python Indent/Outdent)
- * As it executes the calculation for every single terminal/nonTerminal
- * and does not rely on the fact the token vector is **sorted**
- */
-function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {
-    // First (valid) update for this cst node
-    if (isNaN(currNodeLocation.startOffset) === true) {
-        // assumption1: Token location information is either NaN or a valid number
-        // assumption2: Token location information is fully valid if it exist
-        // (both start/end offsets exist and are numbers).
-        currNodeLocation.startOffset = newLocationInfo.startOffset;
-        currNodeLocation.endOffset = newLocationInfo.endOffset;
-    }
-    // Once the startOffset has been updated with a valid number it should never receive
-    // any farther updates as the Token vector is sorted.
-    // We still have to check this this condition for every new possible location info
-    // because with error recovery enabled we may encounter invalid tokens (NaN location props)
-    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
-        currNodeLocation.endOffset = newLocationInfo.endOffset;
-    }
-}
-/**
- * This nodeLocation tracking is not efficient and should only be used
- * when error recovery is enabled or the Token Vector contains virtual Tokens
- * (e.g, Python Indent/Outdent)
- * As it executes the calculation for every single terminal/nonTerminal
- * and does not rely on the fact the token vector is **sorted**
- */
-function setNodeLocationFull(currNodeLocation, newLocationInfo) {
-    // First (valid) update for this cst node
-    if (isNaN(currNodeLocation.startOffset) === true) {
-        // assumption1: Token location information is either NaN or a valid number
-        // assumption2: Token location information is fully valid if it exist
-        // (all start/end props exist and are numbers).
-        currNodeLocation.startOffset = newLocationInfo.startOffset;
-        currNodeLocation.startColumn = newLocationInfo.startColumn;
-        currNodeLocation.startLine = newLocationInfo.startLine;
-        currNodeLocation.endOffset = newLocationInfo.endOffset;
-        currNodeLocation.endColumn = newLocationInfo.endColumn;
-        currNodeLocation.endLine = newLocationInfo.endLine;
-    }
-    // Once the start props has been updated with a valid number it should never receive
-    // any farther updates as the Token vector is sorted.
-    // We still have to check this this condition for every new possible location info
-    // because with error recovery enabled we may encounter invalid tokens (NaN location props)
-    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
-        currNodeLocation.endOffset = newLocationInfo.endOffset;
-        currNodeLocation.endColumn = newLocationInfo.endColumn;
-        currNodeLocation.endLine = newLocationInfo.endLine;
-    }
-}
-function addTerminalToCst(node, token, tokenTypeName) {
-    if (node.children[tokenTypeName] === undefined) {
-        node.children[tokenTypeName] = [token];
-    }
-    else {
-        node.children[tokenTypeName].push(token);
-    }
-}
-function addNoneTerminalToCst(node, ruleName, ruleResult) {
-    if (node.children[ruleName] === undefined) {
-        node.children[ruleName] = [ruleResult];
-    }
-    else {
-        node.children[ruleName].push(ruleResult);
-    }
-}
-
-exports.addNoneTerminalToCst = addNoneTerminalToCst;
-exports.addTerminalToCst = addTerminalToCst;
-exports.setNodeLocationFull = setNodeLocationFull;
-exports.setNodeLocationOnlyOffset = setNodeLocationOnlyOffset;