markdown-flow-ui 0.1.81-beta.11 → 0.1.81-beta.12

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/dependency-injection.js

@@ -6,7 +6,7 @@ function g(e, n, i, r, t, c, a, y, d) {
   const w = [e, n, i, r, t, c, a, y, d].reduce(s, {});
   return l(w);
 }
-const P = /* @__PURE__ */ Symbol("isProxy");
+const P = Symbol("isProxy");
 function l(e, n) {
   const i = new Proxy({}, {
     deleteProperty: () => !1,
@@ -23,7 +23,7 @@ function l(e, n) {
   });
   return i;
 }
-const u = /* @__PURE__ */ Symbol();
+const u = Symbol();
 function f(e, n, i, r) {
   if (n in e) {
     if (e[n] instanceof Error)

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/dependency-injection.js.map

@@ -1 +1 @@
-{"version":3,"file":"dependency-injection.js","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/dependency-injection.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Module;\n(function (Module) {\n    Module.merge = (m1, m2) => _merge(_merge({}, m1), m2);\n})(Module || (Module = {}));\n/**\n * Given a set of modules, the inject function returns a lazily evaluated injector\n * that injects dependencies into the requested service when it is requested the\n * first time. Subsequent requests will return the same service.\n *\n * In the case of cyclic dependencies, an Error will be thrown. This can be fixed\n * by injecting a provider `() => T` instead of a `T`.\n *\n * Please note that the arguments may be objects or arrays. However, the result will\n * be an object. Using it with for..of will have no effect.\n *\n * @param module1 first Module\n * @param module2 (optional) second Module\n * @param module3 (optional) third Module\n * @param module4 (optional) fourth Module\n * @param module5 (optional) fifth Module\n * @param module6 (optional) sixth Module\n * @param module7 (optional) seventh Module\n * @param module8 (optional) eighth Module\n * @param module9 (optional) ninth Module\n * @returns a new object of type I\n */\nexport function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {\n    const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});\n    return _inject(module);\n}\nconst isProxy = Symbol('isProxy');\n/**\n * Eagerly load all services in the given dependency injection container. This is sometimes\n * necessary because services can register event listeners in their constructors.\n */\nexport function eagerLoad(item) {\n    if (item && item[isProxy]) {\n        for (const value of Object.values(item)) {\n            eagerLoad(value);\n        }\n    }\n    return item;\n}\n/**\n * Helper function that returns an injector by creating a proxy.\n * Invariant: injector is of type I. If injector is undefined, then T = I.\n */\nfunction _inject(module, injector) {\n    const proxy = new Proxy({}, {\n        deleteProperty: () => false,\n        set: () => {\n            throw new Error('Cannot set property on injected service container');\n        },\n        get: (obj, prop) => {\n            if (prop === isProxy) {\n                return true;\n            }\n            else {\n                return _resolve(obj, prop, module, injector || proxy);\n            }\n        },\n        getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)), // used by for..in\n        has: (_, prop) => prop in module, // used by ..in..\n        ownKeys: () => [...Object.getOwnPropertyNames(module)] // used by for..in\n    });\n    return proxy;\n}\n/**\n * Internally used to tag a requested dependency, directly before calling the factory.\n * This allows us to find cycles during instance creation.\n */\nconst __requested__ = Symbol();\n/**\n * Returns the value `obj[prop]`. If the value does not exist, yet, it is resolved from\n * the module description. The result of service factories is cached. Groups are\n * recursively proxied.\n *\n * @param obj an object holding all group proxies and services\n * @param prop the key of a value within obj\n * @param module an object containing groups and service factories\n * @param injector the first level proxy that provides access to all values\n * @returns the requested value `obj[prop]`\n * @throws Error if a dependency cycle is detected\n */\nfunction _resolve(obj, prop, module, injector) {\n    if (prop in obj) {\n        if (obj[prop] instanceof Error) {\n            throw new Error('Construction failure. Please make sure that your dependencies are constructable.', { cause: obj[prop] });\n        }\n        if (obj[prop] === __requested__) {\n            throw new Error('Cycle detected. Please make \"' + String(prop) + '\" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');\n        }\n        return obj[prop];\n    }\n    else if (prop in module) {\n        const value = module[prop];\n        obj[prop] = __requested__;\n        try {\n            obj[prop] = (typeof value === 'function') ? value(injector) : _inject(value, injector);\n        }\n        catch (error) {\n            obj[prop] = error instanceof Error ? error : undefined;\n            throw error;\n        }\n        return obj[prop];\n    }\n    else {\n        return undefined;\n    }\n}\n/**\n * Performs a deep-merge of two modules by writing source entries into the target module.\n *\n * @param target the module which is written\n * @param source the module which is read\n * @returns the target module\n */\nfunction _merge(target, source) {\n    if (source) {\n        for (const [key, value2] of Object.entries(source)) {\n            if (value2 !== undefined) {\n                const value1 = target[key];\n                if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {\n                    target[key] = _merge(value1, value2);\n                }\n                else {\n                    target[key] = value2;\n                }\n            }\n        }\n    }\n    return target;\n}\n//# sourceMappingURL=dependency-injection.js.map"],"names":["Module","m1","m2","_merge","inject","module1","module2","module3","module4","module5","module6","module7","module8","module9","module","_inject","isProxy","injector","proxy","obj","prop","_resolve","_","__requested__","value","error","target","source","key","value2","value1"],"mappings":"AAKU,IAACA;AAAA,CACV,SAAUA,GAAQ;AACf,EAAAA,EAAO,QAAQ,CAACC,GAAIC,MAAOC,EAAOA,EAAO,CAAA,GAAIF,CAAE,GAAGC,CAAE;AACxD,GAAGF,MAAWA,IAAS,CAAA,EAAG;AAuBnB,SAASI,EAAOC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAAS;AACpG,QAAMC,IAAS,CAACT,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,CAAO,EAAE,OAAOV,GAAQ,CAAA,CAAE;AAClH,SAAOY,EAAQD,CAAM;AACzB;AACA,MAAME,IAAU,uBAAO,SAAS;AAiBhC,SAASD,EAAQD,GAAQG,GAAU;AAC/B,QAAMC,IAAQ,IAAI,MAAM,IAAI;AAAA,IACxB,gBAAgB,MAAM;AAAA,IACtB,KAAK,MAAM;AACP,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACvE;AAAA,IACA,KAAK,CAACC,GAAKC,MACHA,MAASJ,IACF,KAGAK,EAASF,GAAKC,GAAMN,GAAQG,KAAYC,CAAK;AAAA,IAG5D,0BAA0B,CAACC,GAAKC,OAAUC,EAASF,GAAKC,GAAMN,GAAQG,KAAYC,CAAK,GAAG,OAAO,yBAAyBC,GAAKC,CAAI;AAAA;AAAA,IACnI,KAAK,CAACE,GAAGF,MAASA,KAAQN;AAAA;AAAA,IAC1B,SAAS,MAAM,CAAC,GAAG,OAAO,oBAAoBA,CAAM,CAAC;AAAA;AAAA,EAC7D,CAAK;AACD,SAAOI;AACX;AAKA,MAAMK,IAAgB,uBAAM;AAa5B,SAASF,EAASF,GAAKC,GAAMN,GAAQG,GAAU;AAC3C,MAAIG,KAAQD,GAAK;AACb,QAAIA,EAAIC,CAAI,aAAa;AACrB,YAAM,IAAI,MAAM,oFAAoF,EAAE,OAAOD,EAAIC,CAAI,GAAG;AAE5H,QAAID,EAAIC,CAAI,MAAMG;AACd,YAAM,IAAI,MAAM,kCAAkC,OAAOH,CAAI,IAAI,wGAAwG;AAE7K,WAAOD,EAAIC,CAAI;AAAA,EACnB,WACSA,KAAQN,GAAQ;AACrB,UAAMU,IAAQV,EAAOM,CAAI;AACzB,IAAAD,EAAIC,CAAI,IAAIG;AACZ,QAAI;AACA,MAAAJ,EAAIC,CAAI,IAAK,OAAOI,KAAU,aAAcA,EAAMP,CAAQ,IAAIF,EAAQS,GAAOP,CAAQ;AAAA,IACzF,SACOQ,GAAO;AACV,YAAAN,EAAIC,CAAI,IAAIK,aAAiB,QAAQA,IAAQ,QACvCA;AAAA,IACV;AACA,WAAON,EAAIC,CAAI;AAAA,EACnB;AAEI;AAER;AAQA,SAASjB,EAAOuB,GAAQC,GAAQ;AAC5B,MAAIA;AACA,eAAW,CAACC,GAAKC,CAAM,KAAK,OAAO,QAAQF,CAAM;AAC7C,UAAIE,MAAW,QAAW;AACtB,cAAMC,IAASJ,EAAOE,CAAG;AACzB,QAAIE,MAAW,QAAQD,MAAW,QAAQ,OAAOC,KAAW,YAAY,OAAOD,KAAW,WACtFH,EAAOE,CAAG,IAAIzB,EAAO2B,GAAQD,CAAM,IAGnCH,EAAOE,CAAG,IAAIC;AAAA,MAEtB;AAAA;AAGR,SAAOH;AACX;","x_google_ignoreList":[0]}
+{"version":3,"file":"dependency-injection.js","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/dependency-injection.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Module;\n(function (Module) {\n    Module.merge = (m1, m2) => _merge(_merge({}, m1), m2);\n})(Module || (Module = {}));\n/**\n * Given a set of modules, the inject function returns a lazily evaluated injector\n * that injects dependencies into the requested service when it is requested the\n * first time. Subsequent requests will return the same service.\n *\n * In the case of cyclic dependencies, an Error will be thrown. This can be fixed\n * by injecting a provider `() => T` instead of a `T`.\n *\n * Please note that the arguments may be objects or arrays. However, the result will\n * be an object. Using it with for..of will have no effect.\n *\n * @param module1 first Module\n * @param module2 (optional) second Module\n * @param module3 (optional) third Module\n * @param module4 (optional) fourth Module\n * @param module5 (optional) fifth Module\n * @param module6 (optional) sixth Module\n * @param module7 (optional) seventh Module\n * @param module8 (optional) eighth Module\n * @param module9 (optional) ninth Module\n * @returns a new object of type I\n */\nexport function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {\n    const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});\n    return _inject(module);\n}\nconst isProxy = Symbol('isProxy');\n/**\n * Eagerly load all services in the given dependency injection container. This is sometimes\n * necessary because services can register event listeners in their constructors.\n */\nexport function eagerLoad(item) {\n    if (item && item[isProxy]) {\n        for (const value of Object.values(item)) {\n            eagerLoad(value);\n        }\n    }\n    return item;\n}\n/**\n * Helper function that returns an injector by creating a proxy.\n * Invariant: injector is of type I. If injector is undefined, then T = I.\n */\nfunction _inject(module, injector) {\n    const proxy = new Proxy({}, {\n        deleteProperty: () => false,\n        set: () => {\n            throw new Error('Cannot set property on injected service container');\n        },\n        get: (obj, prop) => {\n            if (prop === isProxy) {\n                return true;\n            }\n            else {\n                return _resolve(obj, prop, module, injector || proxy);\n            }\n        },\n        getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)), // used by for..in\n        has: (_, prop) => prop in module, // used by ..in..\n        ownKeys: () => [...Object.getOwnPropertyNames(module)] // used by for..in\n    });\n    return proxy;\n}\n/**\n * Internally used to tag a requested dependency, directly before calling the factory.\n * This allows us to find cycles during instance creation.\n */\nconst __requested__ = Symbol();\n/**\n * Returns the value `obj[prop]`. If the value does not exist, yet, it is resolved from\n * the module description. The result of service factories is cached. Groups are\n * recursively proxied.\n *\n * @param obj an object holding all group proxies and services\n * @param prop the key of a value within obj\n * @param module an object containing groups and service factories\n * @param injector the first level proxy that provides access to all values\n * @returns the requested value `obj[prop]`\n * @throws Error if a dependency cycle is detected\n */\nfunction _resolve(obj, prop, module, injector) {\n    if (prop in obj) {\n        if (obj[prop] instanceof Error) {\n            throw new Error('Construction failure. Please make sure that your dependencies are constructable.', { cause: obj[prop] });\n        }\n        if (obj[prop] === __requested__) {\n            throw new Error('Cycle detected. Please make \"' + String(prop) + '\" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');\n        }\n        return obj[prop];\n    }\n    else if (prop in module) {\n        const value = module[prop];\n        obj[prop] = __requested__;\n        try {\n            obj[prop] = (typeof value === 'function') ? value(injector) : _inject(value, injector);\n        }\n        catch (error) {\n            obj[prop] = error instanceof Error ? error : undefined;\n            throw error;\n        }\n        return obj[prop];\n    }\n    else {\n        return undefined;\n    }\n}\n/**\n * Performs a deep-merge of two modules by writing source entries into the target module.\n *\n * @param target the module which is written\n * @param source the module which is read\n * @returns the target module\n */\nfunction _merge(target, source) {\n    if (source) {\n        for (const [key, value2] of Object.entries(source)) {\n            if (value2 !== undefined) {\n                const value1 = target[key];\n                if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {\n                    target[key] = _merge(value1, value2);\n                }\n                else {\n                    target[key] = value2;\n                }\n            }\n        }\n    }\n    return target;\n}\n//# sourceMappingURL=dependency-injection.js.map"],"names":["Module","m1","m2","_merge","inject","module1","module2","module3","module4","module5","module6","module7","module8","module9","module","_inject","isProxy","injector","proxy","obj","prop","_resolve","_","__requested__","value","error","target","source","key","value2","value1"],"mappings":"AAKU,IAACA;AAAA,CACV,SAAUA,GAAQ;AACf,EAAAA,EAAO,QAAQ,CAACC,GAAIC,MAAOC,EAAOA,EAAO,CAAA,GAAIF,CAAE,GAAGC,CAAE;AACxD,GAAGF,MAAWA,IAAS,CAAA,EAAG;AAuBnB,SAASI,EAAOC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAAS;AACpG,QAAMC,IAAS,CAACT,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,GAASC,CAAO,EAAE,OAAOV,GAAQ,CAAA,CAAE;AAClH,SAAOY,EAAQD,CAAM;AACzB;AACA,MAAME,IAAU,OAAO,SAAS;AAiBhC,SAASD,EAAQD,GAAQG,GAAU;AAC/B,QAAMC,IAAQ,IAAI,MAAM,IAAI;AAAA,IACxB,gBAAgB,MAAM;AAAA,IACtB,KAAK,MAAM;AACP,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACvE;AAAA,IACA,KAAK,CAACC,GAAKC,MACHA,MAASJ,IACF,KAGAK,EAASF,GAAKC,GAAMN,GAAQG,KAAYC,CAAK;AAAA,IAG5D,0BAA0B,CAACC,GAAKC,OAAUC,EAASF,GAAKC,GAAMN,GAAQG,KAAYC,CAAK,GAAG,OAAO,yBAAyBC,GAAKC,CAAI;AAAA;AAAA,IACnI,KAAK,CAACE,GAAGF,MAASA,KAAQN;AAAA;AAAA,IAC1B,SAAS,MAAM,CAAC,GAAG,OAAO,oBAAoBA,CAAM,CAAC;AAAA;AAAA,EAC7D,CAAK;AACD,SAAOI;AACX;AAKA,MAAMK,IAAgB,OAAM;AAa5B,SAASF,EAASF,GAAKC,GAAMN,GAAQG,GAAU;AAC3C,MAAIG,KAAQD,GAAK;AACb,QAAIA,EAAIC,CAAI,aAAa;AACrB,YAAM,IAAI,MAAM,oFAAoF,EAAE,OAAOD,EAAIC,CAAI,GAAG;AAE5H,QAAID,EAAIC,CAAI,MAAMG;AACd,YAAM,IAAI,MAAM,kCAAkC,OAAOH,CAAI,IAAI,wGAAwG;AAE7K,WAAOD,EAAIC,CAAI;AAAA,EACnB,WACSA,KAAQN,GAAQ;AACrB,UAAMU,IAAQV,EAAOM,CAAI;AACzB,IAAAD,EAAIC,CAAI,IAAIG;AACZ,QAAI;AACA,MAAAJ,EAAIC,CAAI,IAAK,OAAOI,KAAU,aAAcA,EAAMP,CAAQ,IAAIF,EAAQS,GAAOP,CAAQ;AAAA,IACzF,SACOQ,GAAO;AACV,YAAAN,EAAIC,CAAI,IAAIK,aAAiB,QAAQA,IAAQ,QACvCA;AAAA,IACV;AACA,WAAON,EAAIC,CAAI;AAAA,EACnB;AAEI;AAER;AAQA,SAASjB,EAAOuB,GAAQC,GAAQ;AAC5B,MAAIA;AACA,eAAW,CAACC,GAAKC,CAAM,KAAK,OAAO,QAAQF,CAAM;AAC7C,UAAIE,MAAW,QAAW;AACtB,cAAMC,IAASJ,EAAOE,CAAG;AACzB,QAAIE,MAAW,QAAQD,MAAW,QAAQ,OAAOC,KAAW,YAAY,OAAOD,KAAW,WACtFH,EAAOE,CAAG,IAAIzB,EAAO2B,GAAQD,CAAM,IAGnCH,EAAOE,CAAG,IAAIC;AAAA,MAEtB;AAAA;AAGR,SAAOH;AACX;","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/langium-parser.js

@@ -10,7 +10,7 @@ import { isKeyword as m, isAssignment as S, isCrossReference as x } from "../lan
 import { isDataTypeRule as y, getExplicitRuleType as E } from "../utils/grammar-utils.js";
 import { linkContentToContainer as N, assignMandatoryProperties as M, getContainerOfType as L } from "../utils/ast-utils.js";
 import { CstNodeBuilder as A } from "./cst-node-builder.js";
-const c = /* @__PURE__ */ Symbol("Datatype");
+const c = Symbol("Datatype");
 function h(o) {
   return o.$type === c;
 }

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/langium-parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"langium-parser.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/langium-parser.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword } from '../languages/generated/ast.js';\nimport { getExplicitRuleType, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n    return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n    constructor(services) {\n        this._unorderedGroups = new Map();\n        this.allRules = new Map();\n        this.lexer = services.parser.Lexer;\n        const tokens = this.lexer.definition;\n        const production = services.LanguageMetaData.mode === 'production';\n        this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));\n    }\n    alternatives(idx, choices) {\n        this.wrapper.wrapOr(idx, choices);\n    }\n    optional(idx, callback) {\n        this.wrapper.wrapOption(idx, callback);\n    }\n    many(idx, callback) {\n        this.wrapper.wrapMany(idx, callback);\n    }\n    atLeastOne(idx, callback) {\n        this.wrapper.wrapAtLeastOne(idx, callback);\n    }\n    getRule(name) {\n        return this.allRules.get(name);\n    }\n    isRecording() {\n        return this.wrapper.IS_RECORDING;\n    }\n    get unorderedGroups() {\n        return this._unorderedGroups;\n    }\n    getRuleStack() {\n        return this.wrapper.RULE_STACK;\n    }\n    finalize() {\n        this.wrapper.wrapSelfAnalysis();\n    }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n    get current() {\n        return this.stack[this.stack.length - 1];\n    }\n    constructor(services) {\n        super(services);\n        this.nodeBuilder = new CstNodeBuilder();\n        this.stack = [];\n        this.assignmentMap = new Map();\n        this.linker = services.references.Linker;\n        this.converter = services.parser.ValueConverter;\n        this.astReflection = services.shared.AstReflection;\n    }\n    rule(rule, impl) {\n        const type = this.computeRuleType(rule);\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    computeRuleType(rule) {\n        if (rule.fragment) {\n            return undefined;\n        }\n        else if (isDataTypeRule(rule)) {\n            return DatatypeSymbol;\n        }\n        else {\n            const explicit = getExplicitRuleType(rule);\n            return explicit !== null && explicit !== void 0 ? explicit : rule.name;\n        }\n    }\n    parse(input, options = {}) {\n        this.nodeBuilder.buildRootNode(input);\n        const lexerResult = this.lexerResult = this.lexer.tokenize(input);\n        this.wrapper.input = lexerResult.tokens;\n        const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;\n        if (!ruleMethod) {\n            throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');\n        }\n        const result = ruleMethod.call(this.wrapper, {});\n        this.nodeBuilder.addHiddenNodes(lexerResult.hidden);\n        this.unorderedGroups.clear();\n        this.lexerResult = undefined;\n        return {\n            value: result,\n            lexerErrors: lexerResult.errors,\n            lexerReport: lexerResult.report,\n            parserErrors: this.wrapper.errors\n        };\n    }\n    startImplementation($type, implementation) {\n        return (args) => {\n            // Only create a new AST node in case the calling rule is not a fragment rule\n            const createNode = !this.isRecording() && $type !== undefined;\n            if (createNode) {\n                const node = { $type };\n                this.stack.push(node);\n                if ($type === DatatypeSymbol) {\n                    node.value = '';\n                }\n            }\n            let result;\n            try {\n                result = implementation(args);\n            }\n            catch (err) {\n                result = undefined;\n            }\n            if (result === undefined && createNode) {\n                result = this.construct();\n            }\n            return result;\n        };\n    }\n    extractHiddenTokens(token) {\n        const hiddenTokens = this.lexerResult.hidden;\n        if (!hiddenTokens.length) {\n            return [];\n        }\n        const offset = token.startOffset;\n        for (let i = 0; i < hiddenTokens.length; i++) {\n            const token = hiddenTokens[i];\n            if (token.startOffset > offset) {\n                return hiddenTokens.splice(0, i);\n            }\n        }\n        return hiddenTokens.splice(0, hiddenTokens.length);\n    }\n    consume(idx, tokenType, feature) {\n        const token = this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording() && this.isValidToken(token)) {\n            const hiddenTokens = this.extractHiddenTokens(token);\n            this.nodeBuilder.addHiddenNodes(hiddenTokens);\n            const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n            const { assignment, isCrossRef } = this.getAssignment(feature);\n            const current = this.current;\n            if (assignment) {\n                const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n                this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);\n            }\n            else if (isDataTypeNode(current)) {\n                let text = token.image;\n                if (!isKeyword(feature)) {\n                    text = this.converter.convert(text, leafNode).toString();\n                }\n                current.value += text;\n            }\n        }\n    }\n    /**\n     * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n     *\n     * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n     * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n     */\n    isValidToken(token) {\n        return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        let cstNode;\n        if (!this.isRecording() && !fragment) {\n            // We only want to create a new CST node if the subrule actually creates a new AST node.\n            // In other cases like calls of fragment rules the current CST/AST is populated further.\n            // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.\n            // This is intended, as fragment rules only enrich the current AST node\n            cstNode = this.nodeBuilder.buildCompositeNode(feature);\n        }\n        const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);\n        if (!this.isRecording() && cstNode && cstNode.length > 0) {\n            this.performSubruleAssignment(subruleResult, feature, cstNode);\n        }\n    }\n    performSubruleAssignment(result, feature, cstNode) {\n        const { assignment, isCrossRef } = this.getAssignment(feature);\n        if (assignment) {\n            this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);\n        }\n        else if (!assignment) {\n            // If we call a subrule without an assignment we either:\n            // 1. append the result of the subrule (data type rule)\n            // 2. override the current object with the newly parsed object\n            // If the current element is an AST node and the result of the subrule\n            // is a data type rule, we can safely discard the results.\n            const current = this.current;\n            if (isDataTypeNode(current)) {\n                current.value += result.toString();\n            }\n            else if (typeof result === 'object' && result) {\n                const object = this.assignWithoutOverride(result, current);\n                const newItem = object;\n                this.stack.pop();\n                this.stack.push(newItem);\n            }\n        }\n    }\n    action($type, action) {\n        if (!this.isRecording()) {\n            let last = this.current;\n            if (action.feature && action.operator) {\n                last = this.construct();\n                this.nodeBuilder.removeNode(last.$cstNode);\n                const node = this.nodeBuilder.buildCompositeNode(action);\n                node.content.push(last.$cstNode);\n                const newItem = { $type };\n                this.stack.push(newItem);\n                this.assign(action.operator, action.feature, last, last.$cstNode, false);\n            }\n            else {\n                last.$type = $type;\n            }\n        }\n    }\n    construct() {\n        if (this.isRecording()) {\n            return undefined;\n        }\n        const obj = this.current;\n        linkContentToContainer(obj);\n        this.nodeBuilder.construct(obj);\n        this.stack.pop();\n        if (isDataTypeNode(obj)) {\n            return this.converter.convert(obj.value, obj.$cstNode);\n        }\n        else {\n            assignMandatoryProperties(this.astReflection, obj);\n        }\n        return obj;\n    }\n    getAssignment(feature) {\n        if (!this.assignmentMap.has(feature)) {\n            const assignment = getContainerOfType(feature, isAssignment);\n            this.assignmentMap.set(feature, {\n                assignment: assignment,\n                isCrossRef: assignment ? isCrossReference(assignment.terminal) : false\n            });\n        }\n        return this.assignmentMap.get(feature);\n    }\n    assign(operator, feature, value, cstNode, isCrossRef) {\n        const obj = this.current;\n        let item;\n        if (isCrossRef && typeof value === 'string') {\n            item = this.linker.buildReference(obj, feature, cstNode, value);\n        }\n        else {\n            item = value;\n        }\n        switch (operator) {\n            case '=': {\n                obj[feature] = item;\n                break;\n            }\n            case '?=': {\n                obj[feature] = true;\n                break;\n            }\n            case '+=': {\n                if (!Array.isArray(obj[feature])) {\n                    obj[feature] = [];\n                }\n                obj[feature].push(item);\n            }\n        }\n    }\n    assignWithoutOverride(target, source) {\n        for (const [name, existingValue] of Object.entries(source)) {\n            const newValue = target[name];\n            if (newValue === undefined) {\n                target[name] = existingValue;\n            }\n            else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n                existingValue.push(...newValue);\n                target[name] = existingValue;\n            }\n        }\n        // The target was parsed from a unassigned subrule\n        // After the subrule construction, it received a cst node\n        // This CST node will later be overriden by the cst node builder\n        // To prevent references to stale AST nodes in the CST,\n        // we need to remove the reference here\n        const targetCstNode = target.$cstNode;\n        if (targetCstNode) {\n            targetCstNode.astNode = undefined;\n            target.$cstNode = undefined;\n        }\n        return target;\n    }\n    get definitionErrors() {\n        return this.wrapper.definitionErrors;\n    }\n}\nexport class AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage(options) {\n        return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n    }\n    buildNotAllInputParsedMessage(options) {\n        return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n    }\n    buildNoViableAltMessage(options) {\n        return defaultParserErrorProvider.buildNoViableAltMessage(options);\n    }\n    buildEarlyExitMessage(options) {\n        return defaultParserErrorProvider.buildEarlyExitMessage(options);\n    }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage({ expected, actual }) {\n        const expectedMsg = expected.LABEL\n            ? '`' + expected.LABEL + '`'\n            : expected.name.endsWith(':KW')\n                ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n                : `token of type '${expected.name}'`;\n        return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n    }\n    buildNotAllInputParsedMessage({ firstRedundant }) {\n        return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n    }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n    constructor() {\n        super(...arguments);\n        this.tokens = [];\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    action() {\n        // NOOP\n    }\n    construct() {\n        // NOOP\n        return undefined;\n    }\n    parse(input) {\n        this.resetState();\n        const tokens = this.lexer.tokenize(input, { mode: 'partial' });\n        this.tokens = tokens.tokens;\n        this.wrapper.input = [...this.tokens];\n        this.mainRule.call(this.wrapper, {});\n        this.unorderedGroups.clear();\n        return {\n            tokens: this.tokens,\n            elementStack: [...this.lastElementStack],\n            tokenIndex: this.nextTokenIndex\n        };\n    }\n    rule(rule, impl) {\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    resetState() {\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    startImplementation(implementation) {\n        return (args) => {\n            const size = this.keepStackSize();\n            try {\n                implementation(args);\n            }\n            finally {\n                this.resetStackSize(size);\n            }\n        };\n    }\n    removeUnexpectedElements() {\n        this.elementStack.splice(this.stackSize);\n    }\n    keepStackSize() {\n        const size = this.elementStack.length;\n        this.stackSize = size;\n        return size;\n    }\n    resetStackSize(size) {\n        this.removeUnexpectedElements();\n        this.stackSize = size;\n    }\n    consume(idx, tokenType, feature) {\n        this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording()) {\n            this.lastElementStack = [...this.elementStack, feature];\n            this.nextTokenIndex = this.currIdx + 1;\n        }\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        this.before(feature);\n        this.wrapper.wrapSubrule(idx, rule, args);\n        this.after(feature);\n    }\n    before(element) {\n        if (!this.isRecording()) {\n            this.elementStack.push(element);\n        }\n    }\n    after(element) {\n        if (!this.isRecording()) {\n            const index = this.elementStack.lastIndexOf(element);\n            if (index >= 0) {\n                this.elementStack.splice(index);\n            }\n        }\n    }\n    get currIdx() {\n        return this.wrapper.currIdx;\n    }\n}\nconst defaultConfig = {\n    recoveryEnabled: true,\n    nodeLocationTracking: 'full',\n    skipValidations: true,\n    errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n    constructor(tokens, config) {\n        const useDefaultLookahead = config && 'maxLookahead' in config;\n        super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead\n                ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n                : new LLStarLookaheadStrategy({\n                    // If validations are skipped, don't log the lookahead warnings\n                    logging: config.skipValidations ? () => { } : undefined\n                }) }), config));\n    }\n    get IS_RECORDING() {\n        return this.RECORDING_PHASE;\n    }\n    DEFINE_RULE(name, impl) {\n        return this.RULE(name, impl);\n    }\n    wrapSelfAnalysis() {\n        this.performSelfAnalysis();\n    }\n    wrapConsume(idx, tokenType) {\n        return this.consume(idx, tokenType);\n    }\n    wrapSubrule(idx, rule, args) {\n        return this.subrule(idx, rule, {\n            ARGS: [args]\n        });\n    }\n    wrapOr(idx, choices) {\n        this.or(idx, choices);\n    }\n    wrapOption(idx, callback) {\n        this.option(idx, callback);\n    }\n    wrapMany(idx, callback) {\n        this.many(idx, callback);\n    }\n    wrapAtLeastOne(idx, callback) {\n        this.atLeastOne(idx, callback);\n    }\n}\n//# sourceMappingURL=langium-parser.js.map"],"names":["DatatypeSymbol","isDataTypeNode","node","ruleSuffix","withRuleSuffix","name","AbstractLangiumParser","services","tokens","production","ChevrotainWrapper","idx","choices","callback","LangiumParser","CstNodeBuilder","rule","impl","type","ruleMethod","isDataTypeRule","explicit","getExplicitRuleType","input","options","lexerResult","result","$type","implementation","args","createNode","token","hiddenTokens","offset","i","tokenType","feature","leafNode","assignment","isCrossRef","current","convertedValue","isKeyword","text","fragment","cstNode","subruleResult","newItem","action","last","obj","linkContentToContainer","assignMandatoryProperties","getContainerOfType","isAssignment","isCrossReference","operator","value","item","target","source","existingValue","newValue","targetCstNode","AbstractParserErrorMessageProvider","defaultParserErrorProvider","LangiumParserErrorMessageProvider","expected","actual","firstRedundant","LangiumCompletionParser","size","element","index","defaultConfig","EmbeddedActionsParser","config","useDefaultLookahead","LLkLookaheadStrategy","LLStarLookaheadStrategy"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"langium-parser.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/langium-parser.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword } from '../languages/generated/ast.js';\nimport { getExplicitRuleType, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n    return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n    constructor(services) {\n        this._unorderedGroups = new Map();\n        this.allRules = new Map();\n        this.lexer = services.parser.Lexer;\n        const tokens = this.lexer.definition;\n        const production = services.LanguageMetaData.mode === 'production';\n        this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));\n    }\n    alternatives(idx, choices) {\n        this.wrapper.wrapOr(idx, choices);\n    }\n    optional(idx, callback) {\n        this.wrapper.wrapOption(idx, callback);\n    }\n    many(idx, callback) {\n        this.wrapper.wrapMany(idx, callback);\n    }\n    atLeastOne(idx, callback) {\n        this.wrapper.wrapAtLeastOne(idx, callback);\n    }\n    getRule(name) {\n        return this.allRules.get(name);\n    }\n    isRecording() {\n        return this.wrapper.IS_RECORDING;\n    }\n    get unorderedGroups() {\n        return this._unorderedGroups;\n    }\n    getRuleStack() {\n        return this.wrapper.RULE_STACK;\n    }\n    finalize() {\n        this.wrapper.wrapSelfAnalysis();\n    }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n    get current() {\n        return this.stack[this.stack.length - 1];\n    }\n    constructor(services) {\n        super(services);\n        this.nodeBuilder = new CstNodeBuilder();\n        this.stack = [];\n        this.assignmentMap = new Map();\n        this.linker = services.references.Linker;\n        this.converter = services.parser.ValueConverter;\n        this.astReflection = services.shared.AstReflection;\n    }\n    rule(rule, impl) {\n        const type = this.computeRuleType(rule);\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    computeRuleType(rule) {\n        if (rule.fragment) {\n            return undefined;\n        }\n        else if (isDataTypeRule(rule)) {\n            return DatatypeSymbol;\n        }\n        else {\n            const explicit = getExplicitRuleType(rule);\n            return explicit !== null && explicit !== void 0 ? explicit : rule.name;\n        }\n    }\n    parse(input, options = {}) {\n        this.nodeBuilder.buildRootNode(input);\n        const lexerResult = this.lexerResult = this.lexer.tokenize(input);\n        this.wrapper.input = lexerResult.tokens;\n        const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;\n        if (!ruleMethod) {\n            throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');\n        }\n        const result = ruleMethod.call(this.wrapper, {});\n        this.nodeBuilder.addHiddenNodes(lexerResult.hidden);\n        this.unorderedGroups.clear();\n        this.lexerResult = undefined;\n        return {\n            value: result,\n            lexerErrors: lexerResult.errors,\n            lexerReport: lexerResult.report,\n            parserErrors: this.wrapper.errors\n        };\n    }\n    startImplementation($type, implementation) {\n        return (args) => {\n            // Only create a new AST node in case the calling rule is not a fragment rule\n            const createNode = !this.isRecording() && $type !== undefined;\n            if (createNode) {\n                const node = { $type };\n                this.stack.push(node);\n                if ($type === DatatypeSymbol) {\n                    node.value = '';\n                }\n            }\n            let result;\n            try {\n                result = implementation(args);\n            }\n            catch (err) {\n                result = undefined;\n            }\n            if (result === undefined && createNode) {\n                result = this.construct();\n            }\n            return result;\n        };\n    }\n    extractHiddenTokens(token) {\n        const hiddenTokens = this.lexerResult.hidden;\n        if (!hiddenTokens.length) {\n            return [];\n        }\n        const offset = token.startOffset;\n        for (let i = 0; i < hiddenTokens.length; i++) {\n            const token = hiddenTokens[i];\n            if (token.startOffset > offset) {\n                return hiddenTokens.splice(0, i);\n            }\n        }\n        return hiddenTokens.splice(0, hiddenTokens.length);\n    }\n    consume(idx, tokenType, feature) {\n        const token = this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording() && this.isValidToken(token)) {\n            const hiddenTokens = this.extractHiddenTokens(token);\n            this.nodeBuilder.addHiddenNodes(hiddenTokens);\n            const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n            const { assignment, isCrossRef } = this.getAssignment(feature);\n            const current = this.current;\n            if (assignment) {\n                const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n                this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);\n            }\n            else if (isDataTypeNode(current)) {\n                let text = token.image;\n                if (!isKeyword(feature)) {\n                    text = this.converter.convert(text, leafNode).toString();\n                }\n                current.value += text;\n            }\n        }\n    }\n    /**\n     * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n     *\n     * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n     * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n     */\n    isValidToken(token) {\n        return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        let cstNode;\n        if (!this.isRecording() && !fragment) {\n            // We only want to create a new CST node if the subrule actually creates a new AST node.\n            // In other cases like calls of fragment rules the current CST/AST is populated further.\n            // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.\n            // This is intended, as fragment rules only enrich the current AST node\n            cstNode = this.nodeBuilder.buildCompositeNode(feature);\n        }\n        const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);\n        if (!this.isRecording() && cstNode && cstNode.length > 0) {\n            this.performSubruleAssignment(subruleResult, feature, cstNode);\n        }\n    }\n    performSubruleAssignment(result, feature, cstNode) {\n        const { assignment, isCrossRef } = this.getAssignment(feature);\n        if (assignment) {\n            this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);\n        }\n        else if (!assignment) {\n            // If we call a subrule without an assignment we either:\n            // 1. append the result of the subrule (data type rule)\n            // 2. override the current object with the newly parsed object\n            // If the current element is an AST node and the result of the subrule\n            // is a data type rule, we can safely discard the results.\n            const current = this.current;\n            if (isDataTypeNode(current)) {\n                current.value += result.toString();\n            }\n            else if (typeof result === 'object' && result) {\n                const object = this.assignWithoutOverride(result, current);\n                const newItem = object;\n                this.stack.pop();\n                this.stack.push(newItem);\n            }\n        }\n    }\n    action($type, action) {\n        if (!this.isRecording()) {\n            let last = this.current;\n            if (action.feature && action.operator) {\n                last = this.construct();\n                this.nodeBuilder.removeNode(last.$cstNode);\n                const node = this.nodeBuilder.buildCompositeNode(action);\n                node.content.push(last.$cstNode);\n                const newItem = { $type };\n                this.stack.push(newItem);\n                this.assign(action.operator, action.feature, last, last.$cstNode, false);\n            }\n            else {\n                last.$type = $type;\n            }\n        }\n    }\n    construct() {\n        if (this.isRecording()) {\n            return undefined;\n        }\n        const obj = this.current;\n        linkContentToContainer(obj);\n        this.nodeBuilder.construct(obj);\n        this.stack.pop();\n        if (isDataTypeNode(obj)) {\n            return this.converter.convert(obj.value, obj.$cstNode);\n        }\n        else {\n            assignMandatoryProperties(this.astReflection, obj);\n        }\n        return obj;\n    }\n    getAssignment(feature) {\n        if (!this.assignmentMap.has(feature)) {\n            const assignment = getContainerOfType(feature, isAssignment);\n            this.assignmentMap.set(feature, {\n                assignment: assignment,\n                isCrossRef: assignment ? isCrossReference(assignment.terminal) : false\n            });\n        }\n        return this.assignmentMap.get(feature);\n    }\n    assign(operator, feature, value, cstNode, isCrossRef) {\n        const obj = this.current;\n        let item;\n        if (isCrossRef && typeof value === 'string') {\n            item = this.linker.buildReference(obj, feature, cstNode, value);\n        }\n        else {\n            item = value;\n        }\n        switch (operator) {\n            case '=': {\n                obj[feature] = item;\n                break;\n            }\n            case '?=': {\n                obj[feature] = true;\n                break;\n            }\n            case '+=': {\n                if (!Array.isArray(obj[feature])) {\n                    obj[feature] = [];\n                }\n                obj[feature].push(item);\n            }\n        }\n    }\n    assignWithoutOverride(target, source) {\n        for (const [name, existingValue] of Object.entries(source)) {\n            const newValue = target[name];\n            if (newValue === undefined) {\n                target[name] = existingValue;\n            }\n            else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n                existingValue.push(...newValue);\n                target[name] = existingValue;\n            }\n        }\n        // The target was parsed from a unassigned subrule\n        // After the subrule construction, it received a cst node\n        // This CST node will later be overriden by the cst node builder\n        // To prevent references to stale AST nodes in the CST,\n        // we need to remove the reference here\n        const targetCstNode = target.$cstNode;\n        if (targetCstNode) {\n            targetCstNode.astNode = undefined;\n            target.$cstNode = undefined;\n        }\n        return target;\n    }\n    get definitionErrors() {\n        return this.wrapper.definitionErrors;\n    }\n}\nexport class AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage(options) {\n        return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n    }\n    buildNotAllInputParsedMessage(options) {\n        return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n    }\n    buildNoViableAltMessage(options) {\n        return defaultParserErrorProvider.buildNoViableAltMessage(options);\n    }\n    buildEarlyExitMessage(options) {\n        return defaultParserErrorProvider.buildEarlyExitMessage(options);\n    }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage({ expected, actual }) {\n        const expectedMsg = expected.LABEL\n            ? '`' + expected.LABEL + '`'\n            : expected.name.endsWith(':KW')\n                ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n                : `token of type '${expected.name}'`;\n        return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n    }\n    buildNotAllInputParsedMessage({ firstRedundant }) {\n        return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n    }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n    constructor() {\n        super(...arguments);\n        this.tokens = [];\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    action() {\n        // NOOP\n    }\n    construct() {\n        // NOOP\n        return undefined;\n    }\n    parse(input) {\n        this.resetState();\n        const tokens = this.lexer.tokenize(input, { mode: 'partial' });\n        this.tokens = tokens.tokens;\n        this.wrapper.input = [...this.tokens];\n        this.mainRule.call(this.wrapper, {});\n        this.unorderedGroups.clear();\n        return {\n            tokens: this.tokens,\n            elementStack: [...this.lastElementStack],\n            tokenIndex: this.nextTokenIndex\n        };\n    }\n    rule(rule, impl) {\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    resetState() {\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    startImplementation(implementation) {\n        return (args) => {\n            const size = this.keepStackSize();\n            try {\n                implementation(args);\n            }\n            finally {\n                this.resetStackSize(size);\n            }\n        };\n    }\n    removeUnexpectedElements() {\n        this.elementStack.splice(this.stackSize);\n    }\n    keepStackSize() {\n        const size = this.elementStack.length;\n        this.stackSize = size;\n        return size;\n    }\n    resetStackSize(size) {\n        this.removeUnexpectedElements();\n        this.stackSize = size;\n    }\n    consume(idx, tokenType, feature) {\n        this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording()) {\n            this.lastElementStack = [...this.elementStack, feature];\n            this.nextTokenIndex = this.currIdx + 1;\n        }\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        this.before(feature);\n        this.wrapper.wrapSubrule(idx, rule, args);\n        this.after(feature);\n    }\n    before(element) {\n        if (!this.isRecording()) {\n            this.elementStack.push(element);\n        }\n    }\n    after(element) {\n        if (!this.isRecording()) {\n            const index = this.elementStack.lastIndexOf(element);\n            if (index >= 0) {\n                this.elementStack.splice(index);\n            }\n        }\n    }\n    get currIdx() {\n        return this.wrapper.currIdx;\n    }\n}\nconst defaultConfig = {\n    recoveryEnabled: true,\n    nodeLocationTracking: 'full',\n    skipValidations: true,\n    errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n    constructor(tokens, config) {\n        const useDefaultLookahead = config && 'maxLookahead' in config;\n        super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead\n                ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n                : new LLStarLookaheadStrategy({\n                    // If validations are skipped, don't log the lookahead warnings\n                    logging: config.skipValidations ? () => { } : undefined\n                }) }), config));\n    }\n    get IS_RECORDING() {\n        return this.RECORDING_PHASE;\n    }\n    DEFINE_RULE(name, impl) {\n        return this.RULE(name, impl);\n    }\n    wrapSelfAnalysis() {\n        this.performSelfAnalysis();\n    }\n    wrapConsume(idx, tokenType) {\n        return this.consume(idx, tokenType);\n    }\n    wrapSubrule(idx, rule, args) {\n        return this.subrule(idx, rule, {\n            ARGS: [args]\n        });\n    }\n    wrapOr(idx, choices) {\n        this.or(idx, choices);\n    }\n    wrapOption(idx, callback) {\n        this.option(idx, callback);\n    }\n    wrapMany(idx, callback) {\n        this.many(idx, callback);\n    }\n    wrapAtLeastOne(idx, callback) {\n        this.atLeastOne(idx, callback);\n    }\n}\n//# sourceMappingURL=langium-parser.js.map"],"names":["DatatypeSymbol","isDataTypeNode","node","ruleSuffix","withRuleSuffix","name","AbstractLangiumParser","services","tokens","production","ChevrotainWrapper","idx","choices","callback","LangiumParser","CstNodeBuilder","rule","impl","type","ruleMethod","isDataTypeRule","explicit","getExplicitRuleType","input","options","lexerResult","result","$type","implementation","args","createNode","token","hiddenTokens","offset","i","tokenType","feature","leafNode","assignment","isCrossRef","current","convertedValue","isKeyword","text","fragment","cstNode","subruleResult","newItem","action","last","obj","linkContentToContainer","assignMandatoryProperties","getContainerOfType","isAssignment","isCrossReference","operator","value","item","target","source","existingValue","newValue","targetCstNode","AbstractParserErrorMessageProvider","defaultParserErrorProvider","LangiumParserErrorMessageProvider","expected","actual","firstRedundant","LangiumCompletionParser","size","element","index","defaultConfig","EmbeddedActionsParser","config","useDefaultLookahead","LLkLookaheadStrategy","LLStarLookaheadStrategy"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/linker.js

@@ -3,7 +3,7 @@ import { streamAst as m, streamReferences as p, findRootNode as f } from "../uti
 import { interruptAndCheck as _ } from "../utils/promise-utils.js";
 import { DocumentState as h } from "../workspace/documents.js";
 import { c as $ } from "../../../../../../../../../../_virtual/cancellation.js";
-const l = /* @__PURE__ */ Symbol("ref_resolving");
+const l = Symbol("ref_resolving");
 class b {
   constructor(e) {
     this.reflection = e.shared.AstReflection, this.langiumDocuments = () => e.shared.workspace.LangiumDocuments, this.scopeProvider = e.references.ScopeProvider, this.astNodeLocator = e.workspace.AstNodeLocator;

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/linker.js.map

@@ -1 +1 @@
-{"version":3,"file":"linker.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/linker.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isAstNode, isAstNodeDescription, isLinkingError } from '../syntax-tree.js';\nimport { findRootNode, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { DocumentState } from '../workspace/documents.js';\nconst ref_resolving = Symbol('ref_resolving');\nexport class DefaultLinker {\n    constructor(services) {\n        this.reflection = services.shared.AstReflection;\n        this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;\n        this.scopeProvider = services.references.ScopeProvider;\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n    }\n    async link(document, cancelToken = CancellationToken.None) {\n        for (const node of streamAst(document.parseResult.value)) {\n            await interruptAndCheck(cancelToken);\n            streamReferences(node).forEach(ref => this.doLink(ref, document));\n        }\n    }\n    doLink(refInfo, document) {\n        var _a;\n        const ref = refInfo.reference;\n        // The reference may already have been resolved lazily by accessing its `ref` property.\n        if (ref._ref === undefined) {\n            ref._ref = ref_resolving;\n            try {\n                const description = this.getCandidate(refInfo);\n                if (isLinkingError(description)) {\n                    ref._ref = description;\n                }\n                else {\n                    ref._nodeDescription = description;\n                    if (this.langiumDocuments().hasDocument(description.documentUri)) {\n                        // The target document is already loaded\n                        const linkedNode = this.loadAstNode(description);\n                        ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);\n                    }\n                    else {\n                        // Try to load the target AST node later using the already provided description\n                        ref._ref = undefined;\n                    }\n                }\n            }\n            catch (err) {\n                console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);\n                const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n                ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}` });\n            }\n            // Add the reference to the document's array of references\n            // Only add if the reference has been not been resolved earlier\n            // Otherwise we end up with duplicates\n            // See also implementation of `buildReference`\n            document.references.push(ref);\n        }\n    }\n    unlink(document) {\n        for (const ref of document.references) {\n            delete ref._ref;\n            delete ref._nodeDescription;\n        }\n        document.references = [];\n    }\n    getCandidate(refInfo) {\n        const scope = this.scopeProvider.getScope(refInfo);\n        const description = scope.getElement(refInfo.reference.$refText);\n        return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);\n    }\n    buildReference(node, property, refNode, refText) {\n        // See behavior description in doc of Linker, update that on changes in here.\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const linker = this;\n        const reference = {\n            $refNode: refNode,\n            $refText: refText,\n            get ref() {\n                var _a;\n                if (isAstNode(this._ref)) {\n                    // Most frequent case: the target is already resolved.\n                    return this._ref;\n                }\n                else if (isAstNodeDescription(this._nodeDescription)) {\n                    // A candidate has been found before, but it is not loaded yet.\n                    const linkedNode = linker.loadAstNode(this._nodeDescription);\n                    this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);\n                }\n                else if (this._ref === undefined) {\n                    // The reference has not been linked yet, so do that now.\n                    this._ref = ref_resolving;\n                    const document = findRootNode(node).$document;\n                    const refData = linker.getLinkedNode({ reference, container: node, property });\n                    if (refData.error && document && document.state < DocumentState.ComputedScopes) {\n                        // Document scope is not ready, don't set `this._ref` so linker can retry later.\n                        return this._ref = undefined;\n                    }\n                    this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;\n                    this._nodeDescription = refData.descr;\n                    document === null || document === void 0 ? void 0 : document.references.push(this);\n                }\n                else if (this._ref === ref_resolving) {\n                    throw new Error(`Cyclic reference resolution detected: ${linker.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);\n                }\n                return isAstNode(this._ref) ? this._ref : undefined;\n            },\n            get $nodeDescription() {\n                return this._nodeDescription;\n            },\n            get error() {\n                return isLinkingError(this._ref) ? this._ref : undefined;\n            }\n        };\n        return reference;\n    }\n    getLinkedNode(refInfo) {\n        var _a;\n        try {\n            const description = this.getCandidate(refInfo);\n            if (isLinkingError(description)) {\n                return { error: description };\n            }\n            const linkedNode = this.loadAstNode(description);\n            if (linkedNode) {\n                return { node: linkedNode, descr: description };\n            }\n            else {\n                return {\n                    descr: description,\n                    error: this.createLinkingError(refInfo, description)\n                };\n            }\n        }\n        catch (err) {\n            console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);\n            const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n            return {\n                error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}` })\n            };\n        }\n    }\n    loadAstNode(nodeDescription) {\n        if (nodeDescription.node) {\n            return nodeDescription.node;\n        }\n        const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);\n        if (!doc) {\n            return undefined;\n        }\n        return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);\n    }\n    createLinkingError(refInfo, targetDescription) {\n        // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug\n        // in the language implementation.\n        const document = findRootNode(refInfo.container).$document;\n        if (document && document.state < DocumentState.ComputedScopes) {\n            console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);\n        }\n        const referenceType = this.reflection.getReferenceType(refInfo);\n        return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });\n    }\n}\n//# sourceMappingURL=linker.js.map"],"names":["ref_resolving","DefaultLinker","services","document","cancelToken","CancellationToken","node","streamAst","interruptAndCheck","streamReferences","ref","refInfo","_a","description","isLinkingError","linkedNode","err","errorMessage","property","refNode","refText","linker","reference","isAstNode","isAstNodeDescription","findRootNode","refData","DocumentState","nodeDescription","doc","targetDescription","referenceType"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"linker.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/linker.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isAstNode, isAstNodeDescription, isLinkingError } from '../syntax-tree.js';\nimport { findRootNode, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { DocumentState } from '../workspace/documents.js';\nconst ref_resolving = Symbol('ref_resolving');\nexport class DefaultLinker {\n    constructor(services) {\n        this.reflection = services.shared.AstReflection;\n        this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;\n        this.scopeProvider = services.references.ScopeProvider;\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n    }\n    async link(document, cancelToken = CancellationToken.None) {\n        for (const node of streamAst(document.parseResult.value)) {\n            await interruptAndCheck(cancelToken);\n            streamReferences(node).forEach(ref => this.doLink(ref, document));\n        }\n    }\n    doLink(refInfo, document) {\n        var _a;\n        const ref = refInfo.reference;\n        // The reference may already have been resolved lazily by accessing its `ref` property.\n        if (ref._ref === undefined) {\n            ref._ref = ref_resolving;\n            try {\n                const description = this.getCandidate(refInfo);\n                if (isLinkingError(description)) {\n                    ref._ref = description;\n                }\n                else {\n                    ref._nodeDescription = description;\n                    if (this.langiumDocuments().hasDocument(description.documentUri)) {\n                        // The target document is already loaded\n                        const linkedNode = this.loadAstNode(description);\n                        ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);\n                    }\n                    else {\n                        // Try to load the target AST node later using the already provided description\n                        ref._ref = undefined;\n                    }\n                }\n            }\n            catch (err) {\n                console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);\n                const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n                ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}` });\n            }\n            // Add the reference to the document's array of references\n            // Only add if the reference has been not been resolved earlier\n            // Otherwise we end up with duplicates\n            // See also implementation of `buildReference`\n            document.references.push(ref);\n        }\n    }\n    unlink(document) {\n        for (const ref of document.references) {\n            delete ref._ref;\n            delete ref._nodeDescription;\n        }\n        document.references = [];\n    }\n    getCandidate(refInfo) {\n        const scope = this.scopeProvider.getScope(refInfo);\n        const description = scope.getElement(refInfo.reference.$refText);\n        return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);\n    }\n    buildReference(node, property, refNode, refText) {\n        // See behavior description in doc of Linker, update that on changes in here.\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const linker = this;\n        const reference = {\n            $refNode: refNode,\n            $refText: refText,\n            get ref() {\n                var _a;\n                if (isAstNode(this._ref)) {\n                    // Most frequent case: the target is already resolved.\n                    return this._ref;\n                }\n                else if (isAstNodeDescription(this._nodeDescription)) {\n                    // A candidate has been found before, but it is not loaded yet.\n                    const linkedNode = linker.loadAstNode(this._nodeDescription);\n                    this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);\n                }\n                else if (this._ref === undefined) {\n                    // The reference has not been linked yet, so do that now.\n                    this._ref = ref_resolving;\n                    const document = findRootNode(node).$document;\n                    const refData = linker.getLinkedNode({ reference, container: node, property });\n                    if (refData.error && document && document.state < DocumentState.ComputedScopes) {\n                        // Document scope is not ready, don't set `this._ref` so linker can retry later.\n                        return this._ref = undefined;\n                    }\n                    this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;\n                    this._nodeDescription = refData.descr;\n                    document === null || document === void 0 ? void 0 : document.references.push(this);\n                }\n                else if (this._ref === ref_resolving) {\n                    throw new Error(`Cyclic reference resolution detected: ${linker.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);\n                }\n                return isAstNode(this._ref) ? this._ref : undefined;\n            },\n            get $nodeDescription() {\n                return this._nodeDescription;\n            },\n            get error() {\n                return isLinkingError(this._ref) ? this._ref : undefined;\n            }\n        };\n        return reference;\n    }\n    getLinkedNode(refInfo) {\n        var _a;\n        try {\n            const description = this.getCandidate(refInfo);\n            if (isLinkingError(description)) {\n                return { error: description };\n            }\n            const linkedNode = this.loadAstNode(description);\n            if (linkedNode) {\n                return { node: linkedNode, descr: description };\n            }\n            else {\n                return {\n                    descr: description,\n                    error: this.createLinkingError(refInfo, description)\n                };\n            }\n        }\n        catch (err) {\n            console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);\n            const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);\n            return {\n                error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}` })\n            };\n        }\n    }\n    loadAstNode(nodeDescription) {\n        if (nodeDescription.node) {\n            return nodeDescription.node;\n        }\n        const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);\n        if (!doc) {\n            return undefined;\n        }\n        return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);\n    }\n    createLinkingError(refInfo, targetDescription) {\n        // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug\n        // in the language implementation.\n        const document = findRootNode(refInfo.container).$document;\n        if (document && document.state < DocumentState.ComputedScopes) {\n            console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);\n        }\n        const referenceType = this.reflection.getReferenceType(refInfo);\n        return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });\n    }\n}\n//# sourceMappingURL=linker.js.map"],"names":["ref_resolving","DefaultLinker","services","document","cancelToken","CancellationToken","node","streamAst","interruptAndCheck","streamReferences","ref","refInfo","_a","description","isLinkingError","linkedNode","err","errorMessage","property","refNode","refText","linker","reference","isAstNode","isAstNodeDescription","findRootNode","refData","DocumentState","nodeDescription","doc","targetDescription","referenceType"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.js.map

@@ -1 +1 @@
-{"version":3,"file":"scope-computation.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { streamAllContents, streamContents } from '../utils/ast-utils.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\n/**\n * The default scope computation creates and collectes descriptions of the AST nodes to be exported into the\n * _global_ scope from the given document. By default those are the document's root AST node and its directly\n * contained child nodes.\n *\n * Besides, it gathers all AST nodes that have a name (according to the `NameProvider` service) and includes them\n * in the local scope of their particular container nodes. As a result, for every cross-reference in the AST,\n * target elements from the same level (siblings) and further up towards the root (parents and siblings of parents)\n * are visible. Elements being nested inside lower levels (children, children of siblings and parents' siblings)\n * are _invisible_ by default, but that can be changed by customizing this service.\n */\nexport class DefaultScopeComputation {\n    constructor(services) {\n        this.nameProvider = services.references.NameProvider;\n        this.descriptions = services.workspace.AstNodeDescriptionProvider;\n    }\n    async computeExports(document, cancelToken = CancellationToken.None) {\n        return this.computeExportsForNode(document.parseResult.value, document, undefined, cancelToken);\n    }\n    /**\n     * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.\n     * The list of children to be considered is determined by the function parameter {@link children}.\n     * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.\n     *\n     * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.\n     * @param document The document containing the AST node to be exported.\n     * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.\n     * @param cancelToken Indicates when to cancel the current operation.\n     * @throws `OperationCancelled` if a user action occurs during execution.\n     * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.\n     */\n    async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = CancellationToken.None) {\n        const exports = [];\n        this.exportNode(parentNode, exports, document);\n        for (const node of children(parentNode)) {\n            await interruptAndCheck(cancelToken);\n            this.exportNode(node, exports, document);\n        }\n        return exports;\n    }\n    /**\n     * Add a single node to the list of exports if it has a name. Override this method to change how\n     * symbols are exported, e.g. by modifying their exported name.\n     */\n    exportNode(node, exports, document) {\n        const name = this.nameProvider.getName(node);\n        if (name) {\n            exports.push(this.descriptions.createDescription(node, name, document));\n        }\n    }\n    async computeLocalScopes(document, cancelToken = CancellationToken.None) {\n        const rootNode = document.parseResult.value;\n        const scopes = new MultiMap();\n        // Here we navigate the full AST - local scopes shall be available in the whole document\n        for (const node of streamAllContents(rootNode)) {\n            await interruptAndCheck(cancelToken);\n            this.processNode(node, document, scopes);\n        }\n        return scopes;\n    }\n    /**\n     * Process a single node during scopes computation. The default implementation makes the node visible\n     * in the subtree of its container (if the node has a name). Override this method to change this,\n     * e.g. by increasing the visibility to a higher level in the AST.\n     */\n    processNode(node, document, scopes) {\n        const container = node.$container;\n        if (container) {\n            const name = this.nameProvider.getName(node);\n            if (name) {\n                scopes.add(container, this.descriptions.createDescription(node, name, document));\n            }\n        }\n    }\n}\n//# sourceMappingURL=scope-computation.js.map"],"names":["DefaultScopeComputation","services","document","cancelToken","CancellationToken","parentNode","children","streamContents","exports","node","interruptAndCheck","name","rootNode","scopes","MultiMap","streamAllContents","container"],"mappings":";;;;AAoBO,MAAMA,EAAwB;AAAA,EACjC,YAAYC,GAAU;AAClB,SAAK,eAAeA,EAAS,WAAW,cACxC,KAAK,eAAeA,EAAS,UAAU;AAAA,EAC3C;AAAA,EACA,MAAM,eAAeC,GAAUC,IAAcC,EAAAA,kBAAkB,MAAM;AACjE,WAAO,KAAK,sBAAsBF,EAAS,YAAY,OAAOA,GAAU,QAAWC,CAAW;AAAA,EAClG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,sBAAsBE,GAAYH,GAAUI,IAAWC,GAAgBJ,IAAcC,EAAAA,kBAAkB,MAAM;AAC/G,UAAMI,IAAU,CAAA;AAChB,SAAK,WAAWH,GAAYG,GAASN,CAAQ;AAC7C,eAAWO,KAAQH,EAASD,CAAU;AAClC,YAAMK,EAAkBP,CAAW,GACnC,KAAK,WAAWM,GAAMD,GAASN,CAAQ;AAE3C,WAAOM;AAAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,WAAWC,GAAMD,GAASN,GAAU;AAChC,UAAMS,IAAO,KAAK,aAAa,QAAQF,CAAI;AAC3C,IAAIE,KACAH,EAAQ,KAAK,KAAK,aAAa,kBAAkBC,GAAME,GAAMT,CAAQ,CAAC;AAAA,EAE9E;AAAA,EACA,MAAM,mBAAmBA,GAAUC,IAAcC,EAAAA,kBAAkB,MAAM;AACrE,UAAMQ,IAAWV,EAAS,YAAY,OAChCW,IAAS,IAAIC,EAAQ;AAE3B,eAAWL,KAAQM,EAAkBH,CAAQ;AACzC,YAAMF,EAAkBP,CAAW,GACnC,KAAK,YAAYM,GAAMP,GAAUW,CAAM;AAE3C,WAAOA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAYJ,GAAMP,GAAUW,GAAQ;AAChC,UAAMG,IAAYP,EAAK;AACvB,QAAIO,GAAW;AACX,YAAML,IAAO,KAAK,aAAa,QAAQF,CAAI;AAC3C,MAAIE,KACAE,EAAO,IAAIG,GAAW,KAAK,aAAa,kBAAkBP,GAAME,GAAMT,CAAQ,CAAC;AAAA,IAEvF;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"scope-computation.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { streamAllContents, streamContents } from '../utils/ast-utils.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\n/**\n * The default scope computation creates and collectes descriptions of the AST nodes to be exported into the\n * _global_ scope from the given document. By default those are the document's root AST node and its directly\n * contained child nodes.\n *\n * Besides, it gathers all AST nodes that have a name (according to the `NameProvider` service) and includes them\n * in the local scope of their particular container nodes. As a result, for every cross-reference in the AST,\n * target elements from the same level (siblings) and further up towards the root (parents and siblings of parents)\n * are visible. Elements being nested inside lower levels (children, children of siblings and parents' siblings)\n * are _invisible_ by default, but that can be changed by customizing this service.\n */\nexport class DefaultScopeComputation {\n    constructor(services) {\n        this.nameProvider = services.references.NameProvider;\n        this.descriptions = services.workspace.AstNodeDescriptionProvider;\n    }\n    async computeExports(document, cancelToken = CancellationToken.None) {\n        return this.computeExportsForNode(document.parseResult.value, document, undefined, cancelToken);\n    }\n    /**\n     * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.\n     * The list of children to be considered is determined by the function parameter {@link children}.\n     * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.\n     *\n     * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.\n     * @param document The document containing the AST node to be exported.\n     * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.\n     * @param cancelToken Indicates when to cancel the current operation.\n     * @throws `OperationCancelled` if a user action occurs during execution.\n     * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.\n     */\n    async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = CancellationToken.None) {\n        const exports = [];\n        this.exportNode(parentNode, exports, document);\n        for (const node of children(parentNode)) {\n            await interruptAndCheck(cancelToken);\n            this.exportNode(node, exports, document);\n        }\n        return exports;\n    }\n    /**\n     * Add a single node to the list of exports if it has a name. Override this method to change how\n     * symbols are exported, e.g. by modifying their exported name.\n     */\n    exportNode(node, exports, document) {\n        const name = this.nameProvider.getName(node);\n        if (name) {\n            exports.push(this.descriptions.createDescription(node, name, document));\n        }\n    }\n    async computeLocalScopes(document, cancelToken = CancellationToken.None) {\n        const rootNode = document.parseResult.value;\n        const scopes = new MultiMap();\n        // Here we navigate the full AST - local scopes shall be available in the whole document\n        for (const node of streamAllContents(rootNode)) {\n            await interruptAndCheck(cancelToken);\n            this.processNode(node, document, scopes);\n        }\n        return scopes;\n    }\n    /**\n     * Process a single node during scopes computation. The default implementation makes the node visible\n     * in the subtree of its container (if the node has a name). Override this method to change this,\n     * e.g. by increasing the visibility to a higher level in the AST.\n     */\n    processNode(node, document, scopes) {\n        const container = node.$container;\n        if (container) {\n            const name = this.nameProvider.getName(node);\n            if (name) {\n                scopes.add(container, this.descriptions.createDescription(node, name, document));\n            }\n        }\n    }\n}\n//# sourceMappingURL=scope-computation.js.map"],"names":["DefaultScopeComputation","services","document","cancelToken","CancellationToken","parentNode","children","streamContents","exports","node","interruptAndCheck","name","rootNode","scopes","MultiMap","streamAllContents","container"],"mappings":";;;;AAoBO,MAAMA,EAAwB;AAAA,EACjC,YAAYC,GAAU;AAClB,SAAK,eAAeA,EAAS,WAAW,cACxC,KAAK,eAAeA,EAAS,UAAU;AAAA,EAC3C;AAAA,EACA,MAAM,eAAeC,GAAUC,IAAcC,EAAAA,kBAAkB,MAAM;AACjE,WAAO,KAAK,sBAAsBF,EAAS,YAAY,OAAOA,GAAU,QAAWC,CAAW;AAAA,EAClG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,sBAAsBE,GAAYH,GAAUI,IAAWC,GAAgBJ,IAAcC,EAAAA,kBAAkB,MAAM;AAC/G,UAAMI,IAAU,CAAA;AAChB,SAAK,WAAWH,GAAYG,GAASN,CAAQ;AAC7C,eAAWO,KAAQH,EAASD,CAAU;AAClC,YAAMK,EAAkBP,CAAW,GACnC,KAAK,WAAWM,GAAMD,GAASN,CAAQ;AAE3C,WAAOM;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,WAAWC,GAAMD,GAASN,GAAU;AAChC,UAAMS,IAAO,KAAK,aAAa,QAAQF,CAAI;AAC3C,IAAIE,KACAH,EAAQ,KAAK,KAAK,aAAa,kBAAkBC,GAAME,GAAMT,CAAQ,CAAC;AAAA,EAE9E;AAAA,EACA,MAAM,mBAAmBA,GAAUC,IAAcC,EAAAA,kBAAkB,MAAM;AACrE,UAAMQ,IAAWV,EAAS,YAAY,OAChCW,IAAS,IAAIC,EAAQ;AAE3B,eAAWL,KAAQM,EAAkBH,CAAQ;AACzC,YAAMF,EAAkBP,CAAW,GACnC,KAAK,YAAYM,GAAMP,GAAUW,CAAM;AAE3C,WAAOA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAYJ,GAAMP,GAAUW,GAAQ;AAChC,UAAMG,IAAYP,EAAK;AACvB,QAAIO,GAAW;AACX,YAAML,IAAO,KAAK,aAAa,QAAQF,CAAI;AAC3C,MAAIE,KACAE,EAAO,IAAIG,GAAW,KAAK,aAAa,kBAAkBP,GAAME,GAAMT,CAAQ,CAAC;AAAA,IAEvF;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.js

@@ -8,7 +8,7 @@ let t = 0, l = 10;
 function u() {
   return t = performance.now(), new o.CancellationTokenSource();
 }
-const i = /* @__PURE__ */ Symbol("OperationCancelled");
+const i = Symbol("OperationCancelled");
 function f(e) {
   return e === i;
 }

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"promise-utils.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\n/**\n * Delays the execution of the current code to the next tick of the event loop.\n * Don't call this method directly in a tight loop to prevent too many promises from being created.\n */\nexport function delayNextTick() {\n    return new Promise(resolve => {\n        // In case we are running in a non-node environment, `setImmediate` isn't available.\n        // Using `setTimeout` of the browser API accomplishes the same result.\n        if (typeof setImmediate === 'undefined') {\n            setTimeout(resolve, 0);\n        }\n        else {\n            setImmediate(resolve);\n        }\n    });\n}\nlet lastTick = 0;\nlet globalInterruptionPeriod = 10;\n/**\n * Reset the global interruption period and create a cancellation token source.\n */\nexport function startCancelableOperation() {\n    lastTick = performance.now();\n    return new CancellationTokenSource();\n}\n/**\n * Change the period duration for `interruptAndCheck` to the given number of milliseconds.\n * The default value is 10ms.\n */\nexport function setInterruptionPeriod(period) {\n    globalInterruptionPeriod = period;\n}\n/**\n * This symbol may be thrown in an asynchronous context by any Langium service that receives\n * a `CancellationToken`. This means that the promise returned by such a service is rejected with\n * this symbol as rejection reason.\n */\nexport const OperationCancelled = Symbol('OperationCancelled');\n/**\n * Use this in a `catch` block to check whether the thrown object indicates that the operation\n * has been cancelled.\n */\nexport function isOperationCancelled(err) {\n    return err === OperationCancelled;\n}\n/**\n * This function does two things:\n *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined\n *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.\n *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation\n *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.\n *\n * All services in Langium that receive a `CancellationToken` may potentially call this function, so the\n * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to\n * the promise) to avoid that event being exposed as an error.\n */\nexport async function interruptAndCheck(token) {\n    if (token === CancellationToken.None) {\n        // Early exit in case cancellation was disabled by the caller\n        return;\n    }\n    const current = performance.now();\n    if (current - lastTick >= globalInterruptionPeriod) {\n        lastTick = current;\n        await delayNextTick();\n        // prevent calling delayNextTick every iteration of loop\n        // where delayNextTick takes up the majority or all of the\n        // globalInterruptionPeriod itself\n        lastTick = performance.now();\n    }\n    if (token.isCancellationRequested) {\n        throw OperationCancelled;\n    }\n}\n/**\n * Simple implementation of the deferred pattern.\n * An object that exposes a promise and functions to resolve and reject it.\n */\nexport class Deferred {\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = (arg) => {\n                resolve(arg);\n                return this;\n            };\n            this.reject = (err) => {\n                reject(err);\n                return this;\n            };\n        });\n    }\n}\n//# sourceMappingURL=promise-utils.js.map"],"names":["delayNextTick","resolve","lastTick","globalInterruptionPeriod","startCancelableOperation","CancellationTokenSource","OperationCancelled","isOperationCancelled","err","interruptAndCheck","token","CancellationToken","current","Deferred","reject","arg"],"mappings":";AAUO,SAASA,IAAgB;AAC5B,SAAO,IAAI,QAAQ,CAAAC,MAAW;AAG1B,IAAI,OAAO,eAAiB,MACxB,WAAWA,GAAS,CAAC,IAGrB,aAAaA,CAAO;AAAA,EAE5B,CAAC;AACL;AACA,IAAIC,IAAW,GACXC,IAA2B;AAIxB,SAASC,IAA2B;AACvC,SAAAF,IAAW,YAAY,IAAG,GACnB,IAAIG,EAAAA,wBAAuB;AACtC;AAaY,MAACC,IAAqB,uBAAO,oBAAoB;AAKtD,SAASC,EAAqBC,GAAK;AACtC,SAAOA,MAAQF;AACnB;AAYO,eAAeG,EAAkBC,GAAO;AAC3C,MAAIA,MAAUC,EAAAA,kBAAkB;AAE5B;AAEJ,QAAMC,IAAU,YAAY,IAAG;AAS/B,MARIA,IAAUV,KAAYC,MACtBD,IAAWU,GACX,MAAMZ,EAAa,GAInBE,IAAW,YAAY,IAAG,IAE1BQ,EAAM;AACN,UAAMJ;AAEd;AAKO,MAAMO,EAAS;AAAA,EAClB,cAAc;AACV,SAAK,UAAU,IAAI,QAAQ,CAACZ,GAASa,MAAW;AAC5C,WAAK,UAAU,CAACC,OACZd,EAAQc,CAAG,GACJ,OAEX,KAAK,SAAS,CAACP,OACXM,EAAON,CAAG,GACH;AAAA,IAEf,CAAC;AAAA,EACL;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"promise-utils.js","sources":["../../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\n/**\n * Delays the execution of the current code to the next tick of the event loop.\n * Don't call this method directly in a tight loop to prevent too many promises from being created.\n */\nexport function delayNextTick() {\n    return new Promise(resolve => {\n        // In case we are running in a non-node environment, `setImmediate` isn't available.\n        // Using `setTimeout` of the browser API accomplishes the same result.\n        if (typeof setImmediate === 'undefined') {\n            setTimeout(resolve, 0);\n        }\n        else {\n            setImmediate(resolve);\n        }\n    });\n}\nlet lastTick = 0;\nlet globalInterruptionPeriod = 10;\n/**\n * Reset the global interruption period and create a cancellation token source.\n */\nexport function startCancelableOperation() {\n    lastTick = performance.now();\n    return new CancellationTokenSource();\n}\n/**\n * Change the period duration for `interruptAndCheck` to the given number of milliseconds.\n * The default value is 10ms.\n */\nexport function setInterruptionPeriod(period) {\n    globalInterruptionPeriod = period;\n}\n/**\n * This symbol may be thrown in an asynchronous context by any Langium service that receives\n * a `CancellationToken`. This means that the promise returned by such a service is rejected with\n * this symbol as rejection reason.\n */\nexport const OperationCancelled = Symbol('OperationCancelled');\n/**\n * Use this in a `catch` block to check whether the thrown object indicates that the operation\n * has been cancelled.\n */\nexport function isOperationCancelled(err) {\n    return err === OperationCancelled;\n}\n/**\n * This function does two things:\n *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined\n *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.\n *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation\n *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.\n *\n * All services in Langium that receive a `CancellationToken` may potentially call this function, so the\n * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to\n * the promise) to avoid that event being exposed as an error.\n */\nexport async function interruptAndCheck(token) {\n    if (token === CancellationToken.None) {\n        // Early exit in case cancellation was disabled by the caller\n        return;\n    }\n    const current = performance.now();\n    if (current - lastTick >= globalInterruptionPeriod) {\n        lastTick = current;\n        await delayNextTick();\n        // prevent calling delayNextTick every iteration of loop\n        // where delayNextTick takes up the majority or all of the\n        // globalInterruptionPeriod itself\n        lastTick = performance.now();\n    }\n    if (token.isCancellationRequested) {\n        throw OperationCancelled;\n    }\n}\n/**\n * Simple implementation of the deferred pattern.\n * An object that exposes a promise and functions to resolve and reject it.\n */\nexport class Deferred {\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = (arg) => {\n                resolve(arg);\n                return this;\n            };\n            this.reject = (err) => {\n                reject(err);\n                return this;\n            };\n        });\n    }\n}\n//# sourceMappingURL=promise-utils.js.map"],"names":["delayNextTick","resolve","lastTick","globalInterruptionPeriod","startCancelableOperation","CancellationTokenSource","OperationCancelled","isOperationCancelled","err","interruptAndCheck","token","CancellationToken","current","Deferred","reject","arg"],"mappings":";AAUO,SAASA,IAAgB;AAC5B,SAAO,IAAI,QAAQ,CAAAC,MAAW;AAG1B,IAAI,OAAO,eAAiB,MACxB,WAAWA,GAAS,CAAC,IAGrB,aAAaA,CAAO;AAAA,EAE5B,CAAC;AACL;AACA,IAAIC,IAAW,GACXC,IAA2B;AAIxB,SAASC,IAA2B;AACvC,SAAAF,IAAW,YAAY,IAAG,GACnB,IAAIG,EAAAA,wBAAuB;AACtC;AAaY,MAACC,IAAqB,OAAO,oBAAoB;AAKtD,SAASC,EAAqBC,GAAK;AACtC,SAAOA,MAAQF;AACnB;AAYO,eAAeG,EAAkBC,GAAO;AAC3C,MAAIA,MAAUC,EAAAA,kBAAkB;AAE5B;AAEJ,QAAMC,IAAU,YAAY,IAAG;AAS/B,MARIA,IAAUV,KAAYC,MACtBD,IAAWU,GACX,MAAMZ,EAAa,GAInBE,IAAW,YAAY,IAAG,IAE1BQ,EAAM;AACN,UAAMJ;AAEd;AAKO,MAAMO,EAAS;AAAA,EAClB,cAAc;AACV,SAAK,UAAU,IAAI,QAAQ,CAACZ,GAASa,MAAW;AAC5C,WAAK,UAAU,CAACC,OACZd,EAAQc,CAAG,GACJ,OAEX,KAAK,SAAS,CAACP,OACXM,EAAON,CAAG,GACH;AAAA,IAEf,CAAC;AAAA,EACL;AACJ;","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/layout-base@1.0.2/node_modules/layout-base/layout-base.js

@@ -1,6 +1,6 @@
 import { __module as P } from "../../../../../../../../_virtual/layout-base2.js";
 var W = P.exports, b;
-function $() {
+function V() {
   return b ? P.exports : (b = 1, (function(H, k) {
     (function(D, v) {
       H.exports = v();
@@ -1604,6 +1604,6 @@ function $() {
   })(P), P.exports);
 }
 export {
-  $ as __require
+  V as __require
 };
 //# sourceMappingURL=layout-base.js.map

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/layout-base@2.0.1/node_modules/layout-base/layout-base.js

@@ -1,6 +1,6 @@
 import { __module as It } from "../../../../../../../../_virtual/layout-base.js";
 var Wt = It.exports, Yt;
-function $t() {
+function qt() {
   return Yt ? It.exports : (Yt = 1, (function(Xt, Vt) {
     (function(M, d) {
       Xt.exports = d();
@@ -646,11 +646,11 @@ function $t() {
                 if (l < f)
                   return s[0] = u, s[1] = n, s[2] = E, s[3] = t, !1;
               } else {
-                var X = r.height / r.width, R = e.height / e.width, C = (t - n) / (f - l), K = void 0, B = void 0, b = void 0, P = void 0, W = void 0, V = void 0;
+                var X = r.height / r.width, R = e.height / e.width, C = (t - n) / (f - l), B = void 0, $ = void 0, b = void 0, P = void 0, W = void 0, V = void 0;
                 if (-X === C ? l > f ? (s[0] = g, s[1] = p, T = !0) : (s[0] = u, s[1] = a, T = !0) : X === C && (l > f ? (s[0] = o, s[1] = a, T = !0) : (s[0] = c, s[1] = p, T = !0)), -R === C ? f > l ? (s[2] = N, s[3] = m, G = !0) : (s[2] = I, s[3] = D, G = !0) : R === C && (f > l ? (s[2] = E, s[3] = D, G = !0) : (s[2] = x, s[3] = m, G = !0)), T && G)
                   return !1;
-                if (l > f ? n > t ? (K = this.getCardinalDirection(X, C, 4), B = this.getCardinalDirection(R, C, 2)) : (K = this.getCardinalDirection(-X, C, 3), B = this.getCardinalDirection(-R, C, 1)) : n > t ? (K = this.getCardinalDirection(-X, C, 1), B = this.getCardinalDirection(-R, C, 3)) : (K = this.getCardinalDirection(X, C, 2), B = this.getCardinalDirection(R, C, 4)), !T)
-                  switch (K) {
+                if (l > f ? n > t ? (B = this.getCardinalDirection(X, C, 4), $ = this.getCardinalDirection(R, C, 2)) : (B = this.getCardinalDirection(-X, C, 3), $ = this.getCardinalDirection(-R, C, 1)) : n > t ? (B = this.getCardinalDirection(-X, C, 1), $ = this.getCardinalDirection(-R, C, 3)) : (B = this.getCardinalDirection(X, C, 2), $ = this.getCardinalDirection(R, C, 4)), !T)
+                  switch (B) {
                     case 1:
                       P = a, b = l + -y / C, s[0] = b, s[1] = P;
                       break;
@@ -665,7 +665,7 @@ function $t() {
                       break;
                   }
                 if (!G)
-                  switch (B) {
+                  switch ($) {
                     case 1:
                       V = D, W = f + -F / C, s[2] = W, s[3] = V;
                       break;
@@ -1636,11 +1636,11 @@ function $t() {
                 for (var R = n - 1; R >= 0; R--)
                   if (this.s[R] !== 0) {
                     for (var C = R + 1; C < r; C++) {
-                      for (var K = 0, B = R; B < this.m; B++)
-                        K += this.U[B][R] * this.U[B][C];
-                      K = -K / this.U[R][R];
+                      for (var B = 0, $ = R; $ < this.m; $++)
+                        B += this.U[$][R] * this.U[$][C];
+                      B = -B / this.U[R][R];
                       for (var b = R; b < this.m; b++)
-                        this.U[b][C] += K * this.U[b][R];
+                        this.U[b][C] += B * this.U[b][R];
                     }
                     for (var P = R; P < this.m; P++)
                       this.U[P][R] = -this.U[P][R];
@@ -1705,11 +1705,11 @@ function $t() {
                     {
                       var Nt = e[O - 1];
                       e[O - 1] = 0;
-                      for (var $ = O; $ < T; $++) {
-                        var lt = h.hypot(this.s[$], Nt), At = this.s[$] / lt, Rt = Nt / lt;
-                        this.s[$] = lt, Nt = -Rt * e[$], e[$] = At * e[$];
+                      for (var q = O; q < T; q++) {
+                        var lt = h.hypot(this.s[q], Nt), At = this.s[q] / lt, Rt = Nt / lt;
+                        this.s[q] = lt, Nt = -Rt * e[q], e[q] = At * e[q];
                         for (var j = 0; j < this.m; j++)
-                          lt = At * this.U[j][$] + Rt * this.U[j][O - 1], this.U[j][O - 1] = -Rt * this.U[j][$] + At * this.U[j][O - 1], this.U[j][$] = lt;
+                          lt = At * this.U[j][q] + Rt * this.U[j][O - 1], this.U[j][O - 1] = -Rt * this.U[j][q] + At * this.U[j][O - 1], this.U[j][q] = lt;
                       }
                     }
                     break;
@@ -1720,13 +1720,13 @@ function $t() {
                         return S || U;
                       })(ft !== 0, Ct !== 0) && (it = Math.sqrt(ft * ft + Ct), ft < 0 && (it = -it), it = Ct / (ft + it));
                       for (var tt = (xt + rt) * (xt - rt) + it, nt = xt * Pt, A = O; A < T - 1; A++) {
-                        var q = h.hypot(tt, nt), Z = tt / q, Q = nt / q;
-                        A !== O && (e[A - 1] = q), tt = Z * this.s[A] + Q * e[A], e[A] = Z * e[A] - Q * this.s[A], nt = Q * this.s[A + 1], this.s[A + 1] = Z * this.s[A + 1];
+                        var Z = h.hypot(tt, nt), Q = tt / Z, K = nt / Z;
+                        A !== O && (e[A - 1] = Z), tt = Q * this.s[A] + K * e[A], e[A] = Q * e[A] - K * this.s[A], nt = K * this.s[A + 1], this.s[A + 1] = Q * this.s[A + 1];
                         for (var k = 0; k < this.n; k++)
-                          q = Z * this.V[k][A] + Q * this.V[k][A + 1], this.V[k][A + 1] = -Q * this.V[k][A] + Z * this.V[k][A + 1], this.V[k][A] = q;
-                        if (q = h.hypot(tt, nt), Z = tt / q, Q = nt / q, this.s[A] = q, tt = Z * e[A] + Q * this.s[A + 1], this.s[A + 1] = -Q * e[A] + Z * this.s[A + 1], nt = Q * e[A + 1], e[A + 1] = Z * e[A + 1], A < this.m - 1)
+                          Z = Q * this.V[k][A] + K * this.V[k][A + 1], this.V[k][A + 1] = -K * this.V[k][A] + Q * this.V[k][A + 1], this.V[k][A] = Z;
+                        if (Z = h.hypot(tt, nt), Q = tt / Z, K = nt / Z, this.s[A] = Z, tt = Q * e[A] + K * this.s[A + 1], this.s[A + 1] = -K * e[A] + Q * this.s[A + 1], nt = K * e[A + 1], e[A + 1] = Q * e[A + 1], A < this.m - 1)
                           for (var _ = 0; _ < this.m; _++)
-                            q = Z * this.U[_][A] + Q * this.U[_][A + 1], this.U[_][A + 1] = -Q * this.U[_][A] + Z * this.U[_][A + 1], this.U[_][A] = q;
+                            Z = Q * this.U[_][A] + K * this.U[_][A + 1], this.U[_][A + 1] = -K * this.U[_][A] + Q * this.U[_][A + 1], this.U[_][A] = Z;
                       }
                       e[T - 2] = tt;
                     }
@@ -1907,6 +1907,6 @@ function $t() {
   })(It), It.exports);
 }
 export {
-  $t as __require
+  qt as __require
 };
 //# sourceMappingURL=layout-base.js.map

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_assignMergeValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assignMergeValue.js","sources":["../../../../../../../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_assignMergeValue.js"],"sourcesContent":["import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nexport default assignMergeValue;\n"],"names":["assignMergeValue","object","key","value","eq","baseAssignValue"],"mappings":";;AAYA,SAASA,EAAiBC,GAAQC,GAAKC,GAAO;AAC5C,GAAKA,MAAU,UAAa,CAACC,EAAGH,EAAOC,CAAG,GAAGC,CAAK,KAC7CA,MAAU,UAAa,EAAED,KAAOD,OACnCI,EAAgBJ,GAAQC,GAAKC,CAAK;AAEtC;","x_google_ignoreList":[0]}

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseClone.js

@@ -1,56 +1,66 @@
-import F from "./_Stack.js";
-import S from "./_arrayEach.js";
+import S from "./_Stack.js";
+import L from "./_arrayEach.js";
 import B from "./_assignValue.js";
-import E from "./_baseAssign.js";
-import I from "./_baseAssignIn.js";
-import w from "./_cloneBuffer.js";
+import I from "./_baseAssign.js";
+import O from "./_baseAssignIn.js";
+import _ from "./_cloneBuffer.js";
 import M from "./_copyArray.js";
-import O from "./_copySymbols.js";
-import U from "./_copySymbolsIn.js";
-import h from "./_getAllKeys.js";
-import x from "./_getTag.js";
-import L from "./_initCloneArray.js";
-import D from "./_initCloneByTag.js";
-import G from "./_initCloneObject.js";
-import N from "./isArray.js";
-import _ from "./isBuffer.js";
-import K from "./isMap.js";
-import R from "./isObject.js";
-import W from "./isSet.js";
-var l = 2, y = "[object Arguments]", q = "[object Array]", H = "[object Boolean]", J = "[object Date]", P = "[object Error]", s = "[object Function]", Q = "[object GeneratorFunction]", V = "[object Map]", X = "[object Number]", A = "[object Object]", Y = "[object RegExp]", Z = "[object Set]", $ = "[object String]", u = "[object Symbol]", z = "[object WeakMap]", k = "[object ArrayBuffer]", v = "[object DataView]", rr = "[object Float32Array]", or = "[object Float64Array]", tr = "[object Int8Array]", er = "[object Int16Array]", ir = "[object Int32Array]", nr = "[object Uint8Array]", ar = "[object Uint8ClampedArray]", fr = "[object Uint16Array]", mr = "[object Uint32Array]", o = {};
-o[y] = o[q] = o[k] = o[v] = o[H] = o[J] = o[rr] = o[or] = o[tr] = o[er] = o[ir] = o[V] = o[X] = o[A] = o[Y] = o[Z] = o[$] = o[u] = o[nr] = o[ar] = o[fr] = o[mr] = !0;
-o[P] = o[s] = o[z] = !1;
-function c(r, f, m, cr, g, i) {
-  var t, d = f & l;
+import l from "./_copySymbols.js";
+import w from "./_copySymbolsIn.js";
+import D from "./_getAllKeys.js";
+import G from "./_getAllKeysIn.js";
+import N from "./_getTag.js";
+import U from "./_initCloneArray.js";
+import h from "./_initCloneByTag.js";
+import x from "./_initCloneObject.js";
+import K from "./isArray.js";
+import P from "./isBuffer.js";
+import R from "./isMap.js";
+import W from "./isObject.js";
+import Y from "./isSet.js";
+import q from "./keys.js";
+import H from "./keysIn.js";
+var J = 1, Q = 2, V = 4, A = "[object Arguments]", X = "[object Array]", Z = "[object Boolean]", $ = "[object Date]", u = "[object Error]", d = "[object Function]", z = "[object GeneratorFunction]", k = "[object Map]", v = "[object Number]", E = "[object Object]", rr = "[object RegExp]", or = "[object Set]", tr = "[object String]", er = "[object Symbol]", ir = "[object WeakMap]", nr = "[object ArrayBuffer]", fr = "[object DataView]", ar = "[object Float32Array]", mr = "[object Float64Array]", cr = "[object Int8Array]", gr = "[object Int16Array]", pr = "[object Int32Array]", br = "[object Uint8Array]", Tr = "[object Uint8ClampedArray]", jr = "[object Uint16Array]", yr = "[object Uint32Array]", o = {};
+o[A] = o[X] = o[nr] = o[fr] = o[Z] = o[$] = o[ar] = o[mr] = o[cr] = o[gr] = o[pr] = o[k] = o[v] = o[E] = o[rr] = o[or] = o[tr] = o[er] = o[br] = o[Tr] = o[jr] = o[yr] = !0;
+o[u] = o[d] = o[ir] = !1;
+function p(r, f, g, sr, b, i) {
+  var t, m = f & J, c = f & Q, F = f & V;
   if (t !== void 0)
     return t;
-  if (!R(r))
+  if (!W(r))
     return r;
-  var b = N(r);
-  if (b)
-    return t = L(r), M(r, t);
-  var a = x(r), p = a == s || a == Q;
-  if (_(r))
-    return w(r);
-  if (a == A || a == y || p && !g)
-    return t = p ? {} : G(r), d ? U(r, I(t, r)) : O(r, E(t, r));
-  if (!o[a])
-    return g ? r : {};
-  t = D(r, a), i || (i = new F());
-  var T = i.get(r);
-  if (T)
-    return T;
-  i.set(r, t), W(r) ? r.forEach(function(e) {
-    t.add(c(e, f, m, e, r, i));
-  }) : K(r) && r.forEach(function(e, n) {
-    t.set(n, c(e, f, m, n, r, i));
+  var T = K(r);
+  if (T) {
+    if (t = U(r), !m)
+      return M(r, t);
+  } else {
+    var a = N(r), j = a == d || a == z;
+    if (P(r))
+      return _(r, m);
+    if (a == E || a == A || j && !b) {
+      if (t = c || j ? {} : x(r), !m)
+        return c ? w(r, O(t, r)) : l(r, I(t, r));
+    } else {
+      if (!o[a])
+        return b ? r : {};
+      t = h(r, a, m);
+    }
+  }
+  i || (i = new S());
+  var y = i.get(r);
+  if (y)
+    return y;
+  i.set(r, t), Y(r) ? r.forEach(function(e) {
+    t.add(p(e, f, g, e, r, i));
+  }) : R(r) && r.forEach(function(e, n) {
+    t.set(n, p(e, f, g, n, r, i));
   });
-  var C = h, j = b ? void 0 : C(r);
-  return S(j || r, function(e, n) {
-    j && (n = e, e = r[n]), B(t, n, c(e, f, m, n, r, i));
+  var C = F ? c ? G : D : c ? H : q, s = T ? void 0 : C(r);
+  return L(s || r, function(e, n) {
+    s && (n = e, e = r[n]), B(t, n, p(e, f, g, n, r, i));
   }), t;
 }
 export {
-  c as default
+  p as default
 };
 //# sourceMappingURL=_baseClone.js.map