qidian-vue-ui 1.1.49 → 1.1.51

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/syntax-tree.mjs

@@ -0,0 +1,74 @@
+function isAstNode(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.$type === "string";
+}
+function isReference(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.$refText === "string";
+}
+function isAstNodeDescription(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.name === "string" && typeof obj.type === "string" && typeof obj.path === "string";
+}
+function isLinkingError(obj) {
+  return typeof obj === "object" && obj !== null && isAstNode(obj.container) && isReference(obj.reference) && typeof obj.message === "string";
+}
+class AbstractAstReflection {
+  constructor() {
+    this.subtypes = {};
+    this.allSubtypes = {};
+  }
+  isInstance(node, type) {
+    return isAstNode(node) && this.isSubtype(node.$type, type);
+  }
+  isSubtype(subtype, supertype) {
+    if (subtype === supertype) {
+      return true;
+    }
+    let nested = this.subtypes[subtype];
+    if (!nested) {
+      nested = this.subtypes[subtype] = {};
+    }
+    const existing = nested[supertype];
+    if (existing !== void 0) {
+      return existing;
+    } else {
+      const result = this.computeIsSubtype(subtype, supertype);
+      nested[supertype] = result;
+      return result;
+    }
+  }
+  getAllSubTypes(type) {
+    const existing = this.allSubtypes[type];
+    if (existing) {
+      return existing;
+    } else {
+      const allTypes = this.getAllTypes();
+      const types = [];
+      for (const possibleSubType of allTypes) {
+        if (this.isSubtype(possibleSubType, type)) {
+          types.push(possibleSubType);
+        }
+      }
+      this.allSubtypes[type] = types;
+      return types;
+    }
+  }
+}
+function isCompositeCstNode(node) {
+  return typeof node === "object" && node !== null && Array.isArray(node.content);
+}
+function isLeafCstNode(node) {
+  return typeof node === "object" && node !== null && typeof node.tokenType === "object";
+}
+function isRootCstNode(node) {
+  return isCompositeCstNode(node) && typeof node.fullText === "string";
+}
+export {
+  AbstractAstReflection,
+  isAstNode,
+  isAstNodeDescription,
+  isCompositeCstNode,
+  isLeafCstNode,
+  isLinkingError,
+  isReference,
+  isRootCstNode
+};
+//# sourceMappingURL=syntax-tree.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/syntax-tree.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax-tree.mjs","sources":["../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/syntax-tree.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 function isAstNode(obj) {\n    return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';\n}\nexport function isReference(obj) {\n    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string';\n}\nexport function isAstNodeDescription(obj) {\n    return typeof obj === 'object' && obj !== null\n        && typeof obj.name === 'string'\n        && typeof obj.type === 'string'\n        && typeof obj.path === 'string';\n}\nexport function isLinkingError(obj) {\n    return typeof obj === 'object' && obj !== null\n        && isAstNode(obj.container)\n        && isReference(obj.reference)\n        && typeof obj.message === 'string';\n}\n/**\n * An abstract implementation of the {@link AstReflection} interface.\n * Serves to cache subtype computation results to improve performance throughout different parts of Langium.\n */\nexport class AbstractAstReflection {\n    constructor() {\n        this.subtypes = {};\n        this.allSubtypes = {};\n    }\n    isInstance(node, type) {\n        return isAstNode(node) && this.isSubtype(node.$type, type);\n    }\n    isSubtype(subtype, supertype) {\n        if (subtype === supertype) {\n            return true;\n        }\n        let nested = this.subtypes[subtype];\n        if (!nested) {\n            nested = this.subtypes[subtype] = {};\n        }\n        const existing = nested[supertype];\n        if (existing !== undefined) {\n            return existing;\n        }\n        else {\n            const result = this.computeIsSubtype(subtype, supertype);\n            nested[supertype] = result;\n            return result;\n        }\n    }\n    getAllSubTypes(type) {\n        const existing = this.allSubtypes[type];\n        if (existing) {\n            return existing;\n        }\n        else {\n            const allTypes = this.getAllTypes();\n            const types = [];\n            for (const possibleSubType of allTypes) {\n                if (this.isSubtype(possibleSubType, type)) {\n                    types.push(possibleSubType);\n                }\n            }\n            this.allSubtypes[type] = types;\n            return types;\n        }\n    }\n}\nexport function isCompositeCstNode(node) {\n    return typeof node === 'object' && node !== null && Array.isArray(node.content);\n}\nexport function isLeafCstNode(node) {\n    return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';\n}\nexport function isRootCstNode(node) {\n    return isCompositeCstNode(node) && typeof node.fullText === 'string';\n}\n//# sourceMappingURL=syntax-tree.js.map"],"names":[],"mappings":"AAKO,SAAS,UAAU,KAAK;AAC3B,SAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,OAAO,IAAI,UAAU;AAC3E;AACO,SAAS,YAAY,KAAK;AAC7B,SAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,OAAO,IAAI,aAAa;AAC9E;AACO,SAAS,qBAAqB,KAAK;AACtC,SAAO,OAAO,QAAQ,YAAY,QAAQ,QACnC,OAAO,IAAI,SAAS,YACpB,OAAO,IAAI,SAAS,YACpB,OAAO,IAAI,SAAS;AAC/B;AACO,SAAS,eAAe,KAAK;AAChC,SAAO,OAAO,QAAQ,YAAY,QAAQ,QACnC,UAAU,IAAI,SAAS,KACvB,YAAY,IAAI,SAAS,KACzB,OAAO,IAAI,YAAY;AAClC;AAKO,MAAM,sBAAsB;AAAA,EAC/B,cAAc;AACV,SAAK,WAAW,CAAA;AAChB,SAAK,cAAc,CAAA;AAAA,EACvB;AAAA,EACA,WAAW,MAAM,MAAM;AACnB,WAAO,UAAU,IAAI,KAAK,KAAK,UAAU,KAAK,OAAO,IAAI;AAAA,EAC7D;AAAA,EACA,UAAU,SAAS,WAAW;AAC1B,QAAI,YAAY,WAAW;AACvB,aAAO;AAAA,IACX;AACA,QAAI,SAAS,KAAK,SAAS,OAAO;AAClC,QAAI,CAAC,QAAQ;AACT,eAAS,KAAK,SAAS,OAAO,IAAI,CAAA;AAAA,IACtC;AACA,UAAM,WAAW,OAAO,SAAS;AACjC,QAAI,aAAa,QAAW;AACxB,aAAO;AAAA,IACX,OACK;AACD,YAAM,SAAS,KAAK,iBAAiB,SAAS,SAAS;AACvD,aAAO,SAAS,IAAI;AACpB,aAAO;AAAA,IACX;AAAA,EACJ;AAAA,EACA,eAAe,MAAM;AACjB,UAAM,WAAW,KAAK,YAAY,IAAI;AACtC,QAAI,UAAU;AACV,aAAO;AAAA,IACX,OACK;AACD,YAAM,WAAW,KAAK,YAAW;AACjC,YAAM,QAAQ,CAAA;AACd,iBAAW,mBAAmB,UAAU;AACpC,YAAI,KAAK,UAAU,iBAAiB,IAAI,GAAG;AACvC,gBAAM,KAAK,eAAe;AAAA,QAC9B;AAAA,MACJ;AACA,WAAK,YAAY,IAAI,IAAI;AACzB,aAAO;AAAA,IACX;AAAA,EACJ;AACJ;AACO,SAAS,mBAAmB,MAAM;AACrC,SAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,MAAM,QAAQ,KAAK,OAAO;AAClF;AACO,SAAS,cAAc,MAAM;AAChC,SAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,OAAO,KAAK,cAAc;AAClF;AACO,SAAS,cAAc,MAAM;AAChC,SAAO,mBAAmB,IAAI,KAAK,OAAO,KAAK,aAAa;AAChE;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/ast-utils.mjs

@@ -0,0 +1,160 @@
+import { isAstNode, isReference } from "../syntax-tree.mjs";
+import { TreeStreamImpl, StreamImpl, DONE_RESULT } from "./stream.mjs";
+import { inRange } from "./cst-utils.mjs";
+function linkContentToContainer(node) {
+  for (const [name, value] of Object.entries(node)) {
+    if (!name.startsWith("$")) {
+      if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (isAstNode(item)) {
+            item.$container = node;
+            item.$containerProperty = name;
+            item.$containerIndex = index;
+          }
+        });
+      } else if (isAstNode(value)) {
+        value.$container = node;
+        value.$containerProperty = name;
+      }
+    }
+  }
+}
+function getContainerOfType(node, typePredicate) {
+  let item = node;
+  while (item) {
+    if (typePredicate(item)) {
+      return item;
+    }
+    item = item.$container;
+  }
+  return void 0;
+}
+function getDocument(node) {
+  const rootNode = findRootNode(node);
+  const result = rootNode.$document;
+  if (!result) {
+    throw new Error("AST node has no document.");
+  }
+  return result;
+}
+function findRootNode(node) {
+  while (node.$container) {
+    node = node.$container;
+  }
+  return node;
+}
+function streamContents(node, options) {
+  if (!node) {
+    throw new Error("Node must be an AstNode.");
+  }
+  const range = options === null || options === void 0 ? void 0 : options.range;
+  return new StreamImpl(() => ({
+    keys: Object.keys(node),
+    keyIndex: 0,
+    arrayIndex: 0
+  }), (state) => {
+    while (state.keyIndex < state.keys.length) {
+      const property = state.keys[state.keyIndex];
+      if (!property.startsWith("$")) {
+        const value = node[property];
+        if (isAstNode(value)) {
+          state.keyIndex++;
+          if (isAstNodeInRange(value, range)) {
+            return { done: false, value };
+          }
+        } else if (Array.isArray(value)) {
+          while (state.arrayIndex < value.length) {
+            const index = state.arrayIndex++;
+            const element = value[index];
+            if (isAstNode(element) && isAstNodeInRange(element, range)) {
+              return { done: false, value: element };
+            }
+          }
+          state.arrayIndex = 0;
+        }
+      }
+      state.keyIndex++;
+    }
+    return DONE_RESULT;
+  });
+}
+function streamAllContents(root, options) {
+  if (!root) {
+    throw new Error("Root node must be an AstNode.");
+  }
+  return new TreeStreamImpl(root, (node) => streamContents(node, options));
+}
+function streamAst(root, options) {
+  if (!root) {
+    throw new Error("Root node must be an AstNode.");
+  }
+  return new TreeStreamImpl(root, (node) => streamContents(node, options), { includeRoot: true });
+}
+function isAstNodeInRange(astNode, range) {
+  var _a;
+  if (!range) {
+    return true;
+  }
+  const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;
+  if (!nodeRange) {
+    return false;
+  }
+  return inRange(nodeRange, range);
+}
+function streamReferences(node) {
+  return new StreamImpl(() => ({
+    keys: Object.keys(node),
+    keyIndex: 0,
+    arrayIndex: 0
+  }), (state) => {
+    while (state.keyIndex < state.keys.length) {
+      const property = state.keys[state.keyIndex];
+      if (!property.startsWith("$")) {
+        const value = node[property];
+        if (isReference(value)) {
+          state.keyIndex++;
+          return { done: false, value: { reference: value, container: node, property } };
+        } else if (Array.isArray(value)) {
+          while (state.arrayIndex < value.length) {
+            const index = state.arrayIndex++;
+            const element = value[index];
+            if (isReference(element)) {
+              return { done: false, value: { reference: element, container: node, property, index } };
+            }
+          }
+          state.arrayIndex = 0;
+        }
+      }
+      state.keyIndex++;
+    }
+    return DONE_RESULT;
+  });
+}
+function assignMandatoryProperties(reflection, node) {
+  const typeMetaData = reflection.getTypeMetaData(node.$type);
+  const genericNode = node;
+  for (const property of typeMetaData.properties) {
+    if (property.defaultValue !== void 0 && genericNode[property.name] === void 0) {
+      genericNode[property.name] = copyDefaultValue(property.defaultValue);
+    }
+  }
+}
+function copyDefaultValue(propertyType) {
+  if (Array.isArray(propertyType)) {
+    return [...propertyType.map(copyDefaultValue)];
+  } else {
+    return propertyType;
+  }
+}
+export {
+  assignMandatoryProperties,
+  findRootNode,
+  getContainerOfType,
+  getDocument,
+  linkContentToContainer,
+  streamAllContents,
+  streamAst,
+  streamContents,
+  streamReferences
+};
+//# sourceMappingURL=ast-utils.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/ast-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/ast-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 { isAstNode, isReference } from '../syntax-tree.js';\nimport { DONE_RESULT, stream, StreamImpl, TreeStreamImpl } from './stream.js';\nimport { inRange } from './cst-utils.js';\n/**\n * Link the `$container` and other related properties of every AST node that is directly contained\n * in the given `node`.\n */\nexport function linkContentToContainer(node) {\n    for (const [name, value] of Object.entries(node)) {\n        if (!name.startsWith('$')) {\n            if (Array.isArray(value)) {\n                value.forEach((item, index) => {\n                    if (isAstNode(item)) {\n                        item.$container = node;\n                        item.$containerProperty = name;\n                        item.$containerIndex = index;\n                    }\n                });\n            }\n            else if (isAstNode(value)) {\n                value.$container = node;\n                value.$containerProperty = name;\n            }\n        }\n    }\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and return the first\n * node that matches the type predicate. If the start node itself matches, it is returned.\n * If no container matches, `undefined` is returned.\n */\nexport function getContainerOfType(node, typePredicate) {\n    let item = node;\n    while (item) {\n        if (typePredicate(item)) {\n            return item;\n        }\n        item = item.$container;\n    }\n    return undefined;\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and check for existence\n * of a container that matches the given predicate. The start node is included in the checks.\n */\nexport function hasContainerOfType(node, predicate) {\n    let item = node;\n    while (item) {\n        if (predicate(item)) {\n            return true;\n        }\n        item = item.$container;\n    }\n    return false;\n}\n/**\n * Retrieve the document in which the given AST node is contained. A reference to the document is\n * usually held by the root node of the AST.\n *\n * @throws an error if the node is not contained in a document.\n */\nexport function getDocument(node) {\n    const rootNode = findRootNode(node);\n    const result = rootNode.$document;\n    if (!result) {\n        throw new Error('AST node has no document.');\n    }\n    return result;\n}\n/**\n * Returns the root node of the given AST node by following the `$container` references.\n */\nexport function findRootNode(node) {\n    while (node.$container) {\n        node = node.$container;\n    }\n    return node;\n}\n/**\n * Create a stream of all AST nodes that are directly contained in the given node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamContents(node, options) {\n    if (!node) {\n        throw new Error('Node must be an AstNode.');\n    }\n    const range = options === null || options === void 0 ? void 0 : options.range;\n    return new StreamImpl(() => ({\n        keys: Object.keys(node),\n        keyIndex: 0,\n        arrayIndex: 0\n    }), state => {\n        while (state.keyIndex < state.keys.length) {\n            const property = state.keys[state.keyIndex];\n            if (!property.startsWith('$')) {\n                const value = node[property];\n                if (isAstNode(value)) {\n                    state.keyIndex++;\n                    if (isAstNodeInRange(value, range)) {\n                        return { done: false, value };\n                    }\n                }\n                else if (Array.isArray(value)) {\n                    while (state.arrayIndex < value.length) {\n                        const index = state.arrayIndex++;\n                        const element = value[index];\n                        if (isAstNode(element) && isAstNodeInRange(element, range)) {\n                            return { done: false, value: element };\n                        }\n                    }\n                    state.arrayIndex = 0;\n                }\n            }\n            state.keyIndex++;\n        }\n        return DONE_RESULT;\n    });\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.\n * This does not include the root node itself.\n */\nexport function streamAllContents(root, options) {\n    if (!root) {\n        throw new Error('Root node must be an AstNode.');\n    }\n    return new TreeStreamImpl(root, node => streamContents(node, options));\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamAst(root, options) {\n    if (!root) {\n        throw new Error('Root node must be an AstNode.');\n    }\n    else if ((options === null || options === void 0 ? void 0 : options.range) && !isAstNodeInRange(root, options.range)) {\n        // Return an empty stream if the root node isn't in range\n        return new TreeStreamImpl(root, () => []);\n    }\n    return new TreeStreamImpl(root, node => streamContents(node, options), { includeRoot: true });\n}\nfunction isAstNodeInRange(astNode, range) {\n    var _a;\n    if (!range) {\n        return true;\n    }\n    const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;\n    if (!nodeRange) {\n        return false;\n    }\n    return inRange(nodeRange, range);\n}\n/**\n * Create a stream of all cross-references that are held by the given AST node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamReferences(node) {\n    return new StreamImpl(() => ({\n        keys: Object.keys(node),\n        keyIndex: 0,\n        arrayIndex: 0\n    }), state => {\n        while (state.keyIndex < state.keys.length) {\n            const property = state.keys[state.keyIndex];\n            if (!property.startsWith('$')) {\n                const value = node[property];\n                if (isReference(value)) {\n                    state.keyIndex++;\n                    return { done: false, value: { reference: value, container: node, property } };\n                }\n                else if (Array.isArray(value)) {\n                    while (state.arrayIndex < value.length) {\n                        const index = state.arrayIndex++;\n                        const element = value[index];\n                        if (isReference(element)) {\n                            return { done: false, value: { reference: element, container: node, property, index } };\n                        }\n                    }\n                    state.arrayIndex = 0;\n                }\n            }\n            state.keyIndex++;\n        }\n        return DONE_RESULT;\n    });\n}\n/**\n * Returns a Stream of references to the target node from the AstNode tree\n *\n * @param targetNode AstNode we are looking for\n * @param lookup AstNode where we search for references. If not provided, the root node of the document is used as the default value\n */\nexport function findLocalReferences(targetNode, lookup = getDocument(targetNode).parseResult.value) {\n    const refs = [];\n    streamAst(lookup).forEach(node => {\n        streamReferences(node).forEach(refInfo => {\n            if (refInfo.reference.ref === targetNode) {\n                refs.push(refInfo.reference);\n            }\n        });\n    });\n    return stream(refs);\n}\n/**\n * Assigns all mandatory AST properties to the specified node.\n *\n * @param reflection Reflection object used to gather mandatory properties for the node.\n * @param node Specified node is modified in place and properties are directly assigned.\n */\nexport function assignMandatoryProperties(reflection, node) {\n    const typeMetaData = reflection.getTypeMetaData(node.$type);\n    const genericNode = node;\n    for (const property of typeMetaData.properties) {\n        // Only set the value if the property is not already set and if it has a default value\n        if (property.defaultValue !== undefined && genericNode[property.name] === undefined) {\n            genericNode[property.name] = copyDefaultValue(property.defaultValue);\n        }\n    }\n}\nfunction copyDefaultValue(propertyType) {\n    if (Array.isArray(propertyType)) {\n        return [...propertyType.map(copyDefaultValue)];\n    }\n    else {\n        return propertyType;\n    }\n}\n/**\n * Creates a deep copy of the specified AST node.\n * The resulting copy will only contain semantically relevant information, such as the `$type` property and AST properties.\n *\n * References are copied without resolved cross reference. The specified function is used to rebuild them.\n */\nexport function copyAstNode(node, buildReference) {\n    const copy = { $type: node.$type };\n    for (const [name, value] of Object.entries(node)) {\n        if (!name.startsWith('$')) {\n            if (isAstNode(value)) {\n                copy[name] = copyAstNode(value, buildReference);\n            }\n            else if (isReference(value)) {\n                copy[name] = buildReference(copy, name, value.$refNode, value.$refText);\n            }\n            else if (Array.isArray(value)) {\n                const copiedArray = [];\n                for (const element of value) {\n                    if (isAstNode(element)) {\n                        copiedArray.push(copyAstNode(element, buildReference));\n                    }\n                    else if (isReference(element)) {\n                        copiedArray.push(buildReference(copy, name, element.$refNode, element.$refText));\n                    }\n                    else {\n                        copiedArray.push(element);\n                    }\n                }\n                copy[name] = copiedArray;\n            }\n            else {\n                copy[name] = value;\n            }\n        }\n    }\n    linkContentToContainer(copy);\n    return copy;\n}\n//# sourceMappingURL=ast-utils.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.mjs

@@ -0,0 +1,138 @@
+class DisposableCache {
+  constructor() {
+    this.toDispose = [];
+    this.isDisposed = false;
+  }
+  onDispose(disposable) {
+    this.toDispose.push(disposable);
+  }
+  dispose() {
+    this.throwIfDisposed();
+    this.clear();
+    this.isDisposed = true;
+    this.toDispose.forEach((disposable) => disposable.dispose());
+  }
+  throwIfDisposed() {
+    if (this.isDisposed) {
+      throw new Error("This cache has already been disposed");
+    }
+  }
+}
+class SimpleCache extends DisposableCache {
+  constructor() {
+    super(...arguments);
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  has(key) {
+    this.throwIfDisposed();
+    return this.cache.has(key);
+  }
+  set(key, value) {
+    this.throwIfDisposed();
+    this.cache.set(key, value);
+  }
+  get(key, provider) {
+    this.throwIfDisposed();
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    } else if (provider) {
+      const value = provider();
+      this.cache.set(key, value);
+      return value;
+    } else {
+      return void 0;
+    }
+  }
+  delete(key) {
+    this.throwIfDisposed();
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.throwIfDisposed();
+    this.cache.clear();
+  }
+}
+class ContextCache extends DisposableCache {
+  constructor(converter) {
+    super();
+    this.cache = /* @__PURE__ */ new Map();
+    this.converter = converter !== null && converter !== void 0 ? converter : ((value) => value);
+  }
+  has(contextKey, key) {
+    this.throwIfDisposed();
+    return this.cacheForContext(contextKey).has(key);
+  }
+  set(contextKey, key, value) {
+    this.throwIfDisposed();
+    this.cacheForContext(contextKey).set(key, value);
+  }
+  get(contextKey, key, provider) {
+    this.throwIfDisposed();
+    const contextCache = this.cacheForContext(contextKey);
+    if (contextCache.has(key)) {
+      return contextCache.get(key);
+    } else if (provider) {
+      const value = provider();
+      contextCache.set(key, value);
+      return value;
+    } else {
+      return void 0;
+    }
+  }
+  delete(contextKey, key) {
+    this.throwIfDisposed();
+    return this.cacheForContext(contextKey).delete(key);
+  }
+  clear(contextKey) {
+    this.throwIfDisposed();
+    if (contextKey) {
+      const mapKey = this.converter(contextKey);
+      this.cache.delete(mapKey);
+    } else {
+      this.cache.clear();
+    }
+  }
+  cacheForContext(contextKey) {
+    const mapKey = this.converter(contextKey);
+    let documentCache = this.cache.get(mapKey);
+    if (!documentCache) {
+      documentCache = /* @__PURE__ */ new Map();
+      this.cache.set(mapKey, documentCache);
+    }
+    return documentCache;
+  }
+}
+class WorkspaceCache extends SimpleCache {
+  /**
+   * Creates a new workspace cache.
+   *
+   * @param sharedServices Service container instance to hook into document lifecycle events.
+   * @param state Optional document state on which the cache should evict.
+   * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+   * *Deleted* documents are considered in both cases.
+   */
+  constructor(sharedServices, state) {
+    super();
+    if (state) {
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
+        this.clear();
+      }));
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+        if (deleted.length > 0) {
+          this.clear();
+        }
+      }));
+    } else {
+      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
+        this.clear();
+      }));
+    }
+  }
+}
+export {
+  ContextCache,
+  DisposableCache,
+  SimpleCache,
+  WorkspaceCache
+};
+//# sourceMappingURL=caching.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"caching.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2023 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 class DisposableCache {\n    constructor() {\n        this.toDispose = [];\n        this.isDisposed = false;\n    }\n    onDispose(disposable) {\n        this.toDispose.push(disposable);\n    }\n    dispose() {\n        this.throwIfDisposed();\n        this.clear();\n        this.isDisposed = true;\n        this.toDispose.forEach(disposable => disposable.dispose());\n    }\n    throwIfDisposed() {\n        if (this.isDisposed) {\n            throw new Error('This cache has already been disposed');\n        }\n    }\n}\nexport class SimpleCache extends DisposableCache {\n    constructor() {\n        super(...arguments);\n        this.cache = new Map();\n    }\n    has(key) {\n        this.throwIfDisposed();\n        return this.cache.has(key);\n    }\n    set(key, value) {\n        this.throwIfDisposed();\n        this.cache.set(key, value);\n    }\n    get(key, provider) {\n        this.throwIfDisposed();\n        if (this.cache.has(key)) {\n            return this.cache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            this.cache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(key) {\n        this.throwIfDisposed();\n        return this.cache.delete(key);\n    }\n    clear() {\n        this.throwIfDisposed();\n        this.cache.clear();\n    }\n}\nexport class ContextCache extends DisposableCache {\n    constructor(converter) {\n        super();\n        this.cache = new Map();\n        this.converter = converter !== null && converter !== void 0 ? converter : (value => value);\n    }\n    has(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).has(key);\n    }\n    set(contextKey, key, value) {\n        this.throwIfDisposed();\n        this.cacheForContext(contextKey).set(key, value);\n    }\n    get(contextKey, key, provider) {\n        this.throwIfDisposed();\n        const contextCache = this.cacheForContext(contextKey);\n        if (contextCache.has(key)) {\n            return contextCache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            contextCache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).delete(key);\n    }\n    clear(contextKey) {\n        this.throwIfDisposed();\n        if (contextKey) {\n            const mapKey = this.converter(contextKey);\n            this.cache.delete(mapKey);\n        }\n        else {\n            this.cache.clear();\n        }\n    }\n    cacheForContext(contextKey) {\n        const mapKey = this.converter(contextKey);\n        let documentCache = this.cache.get(mapKey);\n        if (!documentCache) {\n            documentCache = new Map();\n            this.cache.set(mapKey, documentCache);\n        }\n        return documentCache;\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to a document.\n * If this document is changed or deleted, all associated key/value pairs are deleted.\n */\nexport class DocumentCache extends ContextCache {\n    /**\n     * Creates a new document cache.\n     *\n     * @param sharedServices Service container instance to hook into document lifecycle events.\n     * @param state Optional document state on which the cache should evict.\n     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n     * *Deleted* documents are considered in both cases.\n     *\n     * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,\n     * which triggers on all documents that have been affected by this change, assuming that the\n     * state is `DocumentState.Linked` or a later state.\n     */\n    constructor(sharedServices, state) {\n        super(uri => uri.toString());\n        if (state) {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onDocumentPhase(state, document => {\n                this.clear(document.uri.toString());\n            }));\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n                for (const uri of deleted) { // react only on deleted documents\n                    this.clear(uri);\n                }\n            }));\n        }\n        else {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((changed, deleted) => {\n                const allUris = changed.concat(deleted); // react on both changed and deleted documents\n                for (const uri of allUris) {\n                    this.clear(uri);\n                }\n            }));\n        }\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to the whole workspace.\n * If any document in the workspace is added, changed or deleted, the whole cache is evicted.\n */\nexport class WorkspaceCache extends SimpleCache {\n    /**\n     * Creates a new workspace cache.\n     *\n     * @param sharedServices Service container instance to hook into document lifecycle events.\n     * @param state Optional document state on which the cache should evict.\n     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.\n     * *Deleted* documents are considered in both cases.\n     */\n    constructor(sharedServices, state) {\n        super();\n        if (state) {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {\n                this.clear();\n            }));\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {\n                if (deleted.length > 0) { // react only on deleted documents\n                    this.clear();\n                }\n            }));\n        }\n        else {\n            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {\n                this.clear();\n            }));\n        }\n    }\n}\n//# sourceMappingURL=caching.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/collections.mjs

@@ -0,0 +1,178 @@
+import { Reduction, stream } from "./stream.mjs";
+class MultiMap {
+  constructor(elements) {
+    this.map = /* @__PURE__ */ new Map();
+    if (elements) {
+      for (const [key, value] of elements) {
+        this.add(key, value);
+      }
+    }
+  }
+  /**
+   * The total number of values in the multimap.
+   */
+  get size() {
+    return Reduction.sum(stream(this.map.values()).map((a) => a.length));
+  }
+  /**
+   * Clear all entries in the multimap.
+   */
+  clear() {
+    this.map.clear();
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method deletes the specific key / value pair from the multimap.
+   *  * Without a value, all values associated with the given key are deleted.
+   *
+   * @returns `true` if a value existed and has been removed, or `false` if the specified
+   *     key / value does not exist.
+   */
+  delete(key, value) {
+    if (value === void 0) {
+      return this.map.delete(key);
+    } else {
+      const values = this.map.get(key);
+      if (values) {
+        const index = values.indexOf(value);
+        if (index >= 0) {
+          if (values.length === 1) {
+            this.map.delete(key);
+          } else {
+            values.splice(index, 1);
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  /**
+   * Returns an array of all values associated with the given key. If no value exists,
+   * an empty array is returned.
+   *
+   * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a
+   * value and `delete` to remove a value from the multimap.
+   */
+  get(key) {
+    var _a;
+    return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.
+   *  * Without a value, this method returns `true` if the given key is present in the multimap.
+   */
+  has(key, value) {
+    if (value === void 0) {
+      return this.map.has(key);
+    } else {
+      const values = this.map.get(key);
+      if (values) {
+        return values.indexOf(value) >= 0;
+      }
+      return false;
+    }
+  }
+  /**
+   * Add the given key / value pair to the multimap.
+   */
+  add(key, value) {
+    if (this.map.has(key)) {
+      this.map.get(key).push(value);
+    } else {
+      this.map.set(key, [value]);
+    }
+    return this;
+  }
+  /**
+   * Add the given set of key / value pairs to the multimap.
+   */
+  addAll(key, values) {
+    if (this.map.has(key)) {
+      this.map.get(key).push(...values);
+    } else {
+      this.map.set(key, Array.from(values));
+    }
+    return this;
+  }
+  /**
+   * Invokes the given callback function for every key / value pair in the multimap.
+   */
+  forEach(callbackfn) {
+    this.map.forEach((array, key) => array.forEach((value) => callbackfn(value, key, this)));
+  }
+  /**
+   * Returns an iterator of key, value pairs for every entry in the map.
+   */
+  [Symbol.iterator]() {
+    return this.entries().iterator();
+  }
+  /**
+   * Returns a stream of key, value pairs for every entry in the map.
+   */
+  entries() {
+    return stream(this.map.entries()).flatMap(([key, array]) => array.map((value) => [key, value]));
+  }
+  /**
+   * Returns a stream of keys in the map.
+   */
+  keys() {
+    return stream(this.map.keys());
+  }
+  /**
+   * Returns a stream of values in the map.
+   */
+  values() {
+    return stream(this.map.values()).flat();
+  }
+  /**
+   * Returns a stream of key, value set pairs for every key in the map.
+   */
+  entriesGroupedByKey() {
+    return stream(this.map.entries());
+  }
+}
+class BiMap {
+  get size() {
+    return this.map.size;
+  }
+  constructor(elements) {
+    this.map = /* @__PURE__ */ new Map();
+    this.inverse = /* @__PURE__ */ new Map();
+    if (elements) {
+      for (const [key, value] of elements) {
+        this.set(key, value);
+      }
+    }
+  }
+  clear() {
+    this.map.clear();
+    this.inverse.clear();
+  }
+  set(key, value) {
+    this.map.set(key, value);
+    this.inverse.set(value, key);
+    return this;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  getKey(value) {
+    return this.inverse.get(value);
+  }
+  delete(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.inverse.delete(value);
+      return true;
+    }
+    return false;
+  }
+}
+export {
+  BiMap,
+  MultiMap
+};
+//# sourceMappingURL=collections.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/collections.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/collections.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 { Reduction, stream } from './stream.js';\n/**\n * A multimap is a variation of a Map that has potentially multiple values for every key.\n */\nexport class MultiMap {\n    constructor(elements) {\n        this.map = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.add(key, value);\n            }\n        }\n    }\n    /**\n     * The total number of values in the multimap.\n     */\n    get size() {\n        return Reduction.sum(stream(this.map.values()).map(a => a.length));\n    }\n    /**\n     * Clear all entries in the multimap.\n     */\n    clear() {\n        this.map.clear();\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method deletes the specific key / value pair from the multimap.\n     *  * Without a value, all values associated with the given key are deleted.\n     *\n     * @returns `true` if a value existed and has been removed, or `false` if the specified\n     *     key / value does not exist.\n     */\n    delete(key, value) {\n        if (value === undefined) {\n            return this.map.delete(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                const index = values.indexOf(value);\n                if (index >= 0) {\n                    if (values.length === 1) {\n                        this.map.delete(key);\n                    }\n                    else {\n                        values.splice(index, 1);\n                    }\n                    return true;\n                }\n            }\n            return false;\n        }\n    }\n    /**\n     * Returns an array of all values associated with the given key. If no value exists,\n     * an empty array is returned.\n     *\n     * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a\n     * value and `delete` to remove a value from the multimap.\n     */\n    get(key) {\n        var _a;\n        return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.\n     *  * Without a value, this method returns `true` if the given key is present in the multimap.\n     */\n    has(key, value) {\n        if (value === undefined) {\n            return this.map.has(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                return values.indexOf(value) >= 0;\n            }\n            return false;\n        }\n    }\n    /**\n     * Add the given key / value pair to the multimap.\n     */\n    add(key, value) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(value);\n        }\n        else {\n            this.map.set(key, [value]);\n        }\n        return this;\n    }\n    /**\n     * Add the given set of key / value pairs to the multimap.\n     */\n    addAll(key, values) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(...values);\n        }\n        else {\n            this.map.set(key, Array.from(values));\n        }\n        return this;\n    }\n    /**\n     * Invokes the given callback function for every key / value pair in the multimap.\n     */\n    forEach(callbackfn) {\n        this.map.forEach((array, key) => array.forEach(value => callbackfn(value, key, this)));\n    }\n    /**\n     * Returns an iterator of key, value pairs for every entry in the map.\n     */\n    [Symbol.iterator]() {\n        return this.entries().iterator();\n    }\n    /**\n     * Returns a stream of key, value pairs for every entry in the map.\n     */\n    entries() {\n        return stream(this.map.entries())\n            .flatMap(([key, array]) => array.map(value => [key, value]));\n    }\n    /**\n     * Returns a stream of keys in the map.\n     */\n    keys() {\n        return stream(this.map.keys());\n    }\n    /**\n     * Returns a stream of values in the map.\n     */\n    values() {\n        return stream(this.map.values()).flat();\n    }\n    /**\n     * Returns a stream of key, value set pairs for every key in the map.\n     */\n    entriesGroupedByKey() {\n        return stream(this.map.entries());\n    }\n}\nexport class BiMap {\n    get size() {\n        return this.map.size;\n    }\n    constructor(elements) {\n        this.map = new Map();\n        this.inverse = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.set(key, value);\n            }\n        }\n    }\n    clear() {\n        this.map.clear();\n        this.inverse.clear();\n    }\n    set(key, value) {\n        this.map.set(key, value);\n        this.inverse.set(value, key);\n        return this;\n    }\n    get(key) {\n        return this.map.get(key);\n    }\n    getKey(value) {\n        return this.inverse.get(value);\n    }\n    delete(key) {\n        const value = this.map.get(key);\n        if (value !== undefined) {\n            this.map.delete(key);\n            this.inverse.delete(value);\n            return true;\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=collections.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}