qidian-vue-ui 1.1.49 → 1.1.51

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

@@ -0,0 +1,127 @@
+import { isCompositeCstNode, isRootCstNode, isLeafCstNode } from "../syntax-tree.mjs";
+import { TreeStreamImpl } from "./stream.mjs";
+function streamCst(node) {
+  return new TreeStreamImpl(node, (element) => {
+    if (isCompositeCstNode(element)) {
+      return element.content;
+    } else {
+      return [];
+    }
+  }, { includeRoot: true });
+}
+function isChildNode(child, parent) {
+  while (child.container) {
+    child = child.container;
+    if (child === parent) {
+      return true;
+    }
+  }
+  return false;
+}
+function tokenToRange(token) {
+  return {
+    start: {
+      character: token.startColumn - 1,
+      line: token.startLine - 1
+    },
+    end: {
+      character: token.endColumn,
+      // endColumn uses the correct index
+      line: token.endLine - 1
+    }
+  };
+}
+function toDocumentSegment(node) {
+  if (!node) {
+    return void 0;
+  }
+  const { offset, end, range } = node;
+  return {
+    range,
+    offset,
+    end,
+    length: end - offset
+  };
+}
+var RangeComparison;
+(function(RangeComparison2) {
+  RangeComparison2[RangeComparison2["Before"] = 0] = "Before";
+  RangeComparison2[RangeComparison2["After"] = 1] = "After";
+  RangeComparison2[RangeComparison2["OverlapFront"] = 2] = "OverlapFront";
+  RangeComparison2[RangeComparison2["OverlapBack"] = 3] = "OverlapBack";
+  RangeComparison2[RangeComparison2["Inside"] = 4] = "Inside";
+  RangeComparison2[RangeComparison2["Outside"] = 5] = "Outside";
+})(RangeComparison || (RangeComparison = {}));
+function compareRange(range, to) {
+  if (range.end.line < to.start.line || range.end.line === to.start.line && range.end.character <= to.start.character) {
+    return RangeComparison.Before;
+  } else if (range.start.line > to.end.line || range.start.line === to.end.line && range.start.character >= to.end.character) {
+    return RangeComparison.After;
+  }
+  const startInside = range.start.line > to.start.line || range.start.line === to.start.line && range.start.character >= to.start.character;
+  const endInside = range.end.line < to.end.line || range.end.line === to.end.line && range.end.character <= to.end.character;
+  if (startInside && endInside) {
+    return RangeComparison.Inside;
+  } else if (startInside) {
+    return RangeComparison.OverlapBack;
+  } else if (endInside) {
+    return RangeComparison.OverlapFront;
+  } else {
+    return RangeComparison.Outside;
+  }
+}
+function inRange(range, to) {
+  const comparison = compareRange(range, to);
+  return comparison > RangeComparison.After;
+}
+const DefaultNameRegexp = /^[\w\p{L}]$/u;
+function findCommentNode(cstNode, commentNames) {
+  if (cstNode) {
+    const previous = getPreviousNode(cstNode, true);
+    if (previous && isCommentNode(previous, commentNames)) {
+      return previous;
+    }
+    if (isRootCstNode(cstNode)) {
+      const endIndex = cstNode.content.findIndex((e) => !e.hidden);
+      for (let i = endIndex - 1; i >= 0; i--) {
+        const child = cstNode.content[i];
+        if (isCommentNode(child, commentNames)) {
+          return child;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function isCommentNode(cstNode, commentNames) {
+  return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);
+}
+function getPreviousNode(node, hidden = true) {
+  while (node.container) {
+    const parent = node.container;
+    let index = parent.content.indexOf(node);
+    while (index > 0) {
+      index--;
+      const previous = parent.content[index];
+      if (hidden || !previous.hidden) {
+        return previous;
+      }
+    }
+    node = parent;
+  }
+  return void 0;
+}
+export {
+  DefaultNameRegexp,
+  RangeComparison,
+  compareRange,
+  findCommentNode,
+  getPreviousNode,
+  inRange,
+  isChildNode,
+  isCommentNode,
+  streamCst,
+  toDocumentSegment,
+  tokenToRange
+};
+//# sourceMappingURL=cst-utils.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cst-utils.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/cst-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 { isCompositeCstNode, isLeafCstNode, isRootCstNode } from '../syntax-tree.js';\nimport { TreeStreamImpl } from './stream.js';\n/**\n * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamCst(node) {\n    return new TreeStreamImpl(node, element => {\n        if (isCompositeCstNode(element)) {\n            return element.content;\n        }\n        else {\n            return [];\n        }\n    }, { includeRoot: true });\n}\n/**\n * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.\n */\nexport function flattenCst(node) {\n    return streamCst(node).filter(isLeafCstNode);\n}\n/**\n * Determines whether the specified cst node is a child of the specified parent node.\n */\nexport function isChildNode(child, parent) {\n    while (child.container) {\n        child = child.container;\n        if (child === parent) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tokenToRange(token) {\n    // Chevrotain uses 1-based indices everywhere\n    // So we subtract 1 from every value to align with the LSP\n    return {\n        start: {\n            character: token.startColumn - 1,\n            line: token.startLine - 1\n        },\n        end: {\n            character: token.endColumn, // endColumn uses the correct index\n            line: token.endLine - 1\n        }\n    };\n}\nexport function toDocumentSegment(node) {\n    if (!node) {\n        return undefined;\n    }\n    const { offset, end, range } = node;\n    return {\n        range,\n        offset,\n        end,\n        length: end - offset\n    };\n}\nexport var RangeComparison;\n(function (RangeComparison) {\n    RangeComparison[RangeComparison[\"Before\"] = 0] = \"Before\";\n    RangeComparison[RangeComparison[\"After\"] = 1] = \"After\";\n    RangeComparison[RangeComparison[\"OverlapFront\"] = 2] = \"OverlapFront\";\n    RangeComparison[RangeComparison[\"OverlapBack\"] = 3] = \"OverlapBack\";\n    RangeComparison[RangeComparison[\"Inside\"] = 4] = \"Inside\";\n    RangeComparison[RangeComparison[\"Outside\"] = 5] = \"Outside\";\n})(RangeComparison || (RangeComparison = {}));\nexport function compareRange(range, to) {\n    if (range.end.line < to.start.line || (range.end.line === to.start.line && range.end.character <= to.start.character)) {\n        return RangeComparison.Before;\n    }\n    else if (range.start.line > to.end.line || (range.start.line === to.end.line && range.start.character >= to.end.character)) {\n        return RangeComparison.After;\n    }\n    const startInside = range.start.line > to.start.line || (range.start.line === to.start.line && range.start.character >= to.start.character);\n    const endInside = range.end.line < to.end.line || (range.end.line === to.end.line && range.end.character <= to.end.character);\n    if (startInside && endInside) {\n        return RangeComparison.Inside;\n    }\n    else if (startInside) {\n        return RangeComparison.OverlapBack;\n    }\n    else if (endInside) {\n        return RangeComparison.OverlapFront;\n    }\n    else {\n        return RangeComparison.Outside;\n    }\n}\nexport function inRange(range, to) {\n    const comparison = compareRange(range, to);\n    return comparison > RangeComparison.After;\n}\n// The \\p{L} regex matches any unicode letter character, i.e. characters from non-english alphabets\n// Together with \\w it matches any kind of character which can commonly appear in IDs\nexport const DefaultNameRegexp = /^[\\w\\p{L}]$/u;\n/**\n * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,\n * it will instead return the leaf node at the `offset - 1` position.\n *\n * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.\n */\nexport function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) {\n    if (cstNode) {\n        if (offset > 0) {\n            const localOffset = offset - cstNode.offset;\n            const textAtOffset = cstNode.text.charAt(localOffset);\n            if (!nameRegexp.test(textAtOffset)) {\n                offset--;\n            }\n        }\n        return findLeafNodeAtOffset(cstNode, offset);\n    }\n    return undefined;\n}\nexport function findCommentNode(cstNode, commentNames) {\n    if (cstNode) {\n        const previous = getPreviousNode(cstNode, true);\n        if (previous && isCommentNode(previous, commentNames)) {\n            return previous;\n        }\n        if (isRootCstNode(cstNode)) {\n            // Go from the first non-hidden node through all nodes in reverse order\n            // We do this to find the comment node which directly precedes the root node\n            const endIndex = cstNode.content.findIndex(e => !e.hidden);\n            for (let i = endIndex - 1; i >= 0; i--) {\n                const child = cstNode.content[i];\n                if (isCommentNode(child, commentNames)) {\n                    return child;\n                }\n            }\n        }\n    }\n    return undefined;\n}\nexport function isCommentNode(cstNode, commentNames) {\n    return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * Note that the given offset will be within the range of the returned leaf node.\n *\n * If the offset does not point to a CST node (but just white space), this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node at the specified offset.\n */\nexport function findLeafNodeAtOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, false);\n        if (searchResult) {\n            return findLeafNodeAtOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * If no CST node exists at the specified position, it will return the leaf node before it.\n *\n * If there is no leaf node before the specified offset, this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node closest to the specified offset.\n */\nexport function findLeafNodeBeforeOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, true);\n        if (searchResult) {\n            return findLeafNodeBeforeOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\nfunction binarySearch(node, offset, closest) {\n    let left = 0;\n    let right = node.content.length - 1;\n    let closestNode = undefined;\n    while (left <= right) {\n        const middle = Math.floor((left + right) / 2);\n        const middleNode = node.content[middle];\n        if (middleNode.offset <= offset && middleNode.end > offset) {\n            // Found an exact match\n            return middleNode;\n        }\n        if (middleNode.end <= offset) {\n            // Update the closest node (less than offset) and move to the right half\n            closestNode = closest ? middleNode : undefined;\n            left = middle + 1;\n        }\n        else {\n            // Move to the left half\n            right = middle - 1;\n        }\n    }\n    return closestNode;\n}\nexport function getPreviousNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        while (index > 0) {\n            index--;\n            const previous = parent.content[index];\n            if (hidden || !previous.hidden) {\n                return previous;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getNextNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        const last = parent.content.length - 1;\n        while (index < last) {\n            index++;\n            const next = parent.content[index];\n            if (hidden || !next.hidden) {\n                return next;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getStartlineNode(node) {\n    if (node.range.start.character === 0) {\n        return node;\n    }\n    const line = node.range.start.line;\n    let last = node;\n    let index;\n    while (node.container) {\n        const parent = node.container;\n        const selfIndex = index !== null && index !== void 0 ? index : parent.content.indexOf(node);\n        if (selfIndex === 0) {\n            node = parent;\n            index = undefined;\n        }\n        else {\n            index = selfIndex - 1;\n            node = parent.content[index];\n        }\n        if (node.range.start.line !== line) {\n            break;\n        }\n        last = node;\n    }\n    return last;\n}\nexport function getInteriorNodes(start, end) {\n    const commonParent = getCommonParent(start, end);\n    if (!commonParent) {\n        return [];\n    }\n    return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b);\n}\nfunction getCommonParent(a, b) {\n    const aParents = getParentChain(a);\n    const bParents = getParentChain(b);\n    let current;\n    for (let i = 0; i < aParents.length && i < bParents.length; i++) {\n        const aParent = aParents[i];\n        const bParent = bParents[i];\n        if (aParent.parent === bParent.parent) {\n            current = {\n                parent: aParent.parent,\n                a: aParent.index,\n                b: bParent.index\n            };\n        }\n        else {\n            break;\n        }\n    }\n    return current;\n}\nfunction getParentChain(node) {\n    const chain = [];\n    while (node.container) {\n        const parent = node.container;\n        const index = parent.content.indexOf(node);\n        chain.push({\n            parent,\n            index\n        });\n        node = parent;\n    }\n    return chain.reverse();\n}\n//# sourceMappingURL=cst-utils.js.map"],"names":["RangeComparison"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,13 @@
+var Disposable;
+(function(Disposable2) {
+  function create(callback) {
+    return {
+      dispose: async () => await callback()
+    };
+  }
+  Disposable2.create = create;
+})(Disposable || (Disposable = {}));
+export {
+  Disposable
+};
+//# sourceMappingURL=disposable.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/disposable.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 Disposable;\n(function (Disposable) {\n    function create(callback) {\n        return {\n            dispose: async () => await callback()\n        };\n    }\n    Disposable.create = create;\n})(Disposable || (Disposable = {}));\n//# sourceMappingURL=disposable.js.map"],"names":["Disposable"],"mappings":"AAKU,IAAC;AAAA,CACV,SAAUA,aAAY;AACnB,WAAS,OAAO,UAAU;AACtB,WAAO;AAAA,MACH,SAAS,YAAY,MAAM,SAAQ;AAAA,IAC/C;AAAA,EACI;AACA,EAAAA,YAAW,SAAS;AACxB,GAAG,eAAe,aAAa,CAAA,EAAG;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,13 @@
+class ErrorWithLocation extends Error {
+  constructor(node, message) {
+    super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);
+  }
+}
+function assertUnreachable(_) {
+  throw new Error("Error! The input value was not handled.");
+}
+export {
+  ErrorWithLocation,
+  assertUnreachable
+};
+//# sourceMappingURL=errors.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/errors.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 class ErrorWithLocation extends Error {\n    constructor(node, message) {\n        super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);\n    }\n}\nexport function assertUnreachable(_) {\n    throw new Error('Error! The input value was not handled.');\n}\n//# sourceMappingURL=errors.js.map"],"names":[],"mappings":"AAKO,MAAM,0BAA0B,MAAM;AAAA,EACzC,YAAY,MAAM,SAAS;AACvB,UAAM,OAAO,GAAG,OAAO,OAAO,KAAK,MAAM,MAAM,IAAI,IAAI,KAAK,MAAM,MAAM,SAAS,KAAK,OAAO;AAAA,EACjG;AACJ;AACO,SAAS,kBAAkB,GAAG;AACjC,QAAM,IAAI,MAAM,yCAAyC;AAC7D;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,34 @@
+import { createDefaultSharedCoreModule, createDefaultCoreModule } from "../default-module.mjs";
+import { inject } from "../dependency-injection.mjs";
+import { LangiumGrammarAstReflection } from "../languages/generated/ast.mjs";
+import { EmptyFileSystem } from "../workspace/file-system-provider.mjs";
+import "./uri-utils.mjs";
+import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
+const minimalGrammarModule = {
+  Grammar: () => void 0,
+  LanguageMetaData: () => ({
+    caseInsensitive: false,
+    fileExtensions: [".langium"],
+    languageId: "langium"
+  })
+};
+const minimalSharedGrammarModule = {
+  AstReflection: () => new LangiumGrammarAstReflection()
+};
+function createMinimalGrammarServices() {
+  const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);
+  const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);
+  shared.ServiceRegistry.register(grammar);
+  return grammar;
+}
+function loadGrammarFromJson(json) {
+  var _a;
+  const services = createMinimalGrammarServices();
+  const astNode = services.serializer.JsonSerializer.deserialize(json);
+  services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : "grammar"}.langium`));
+  return astNode;
+}
+export {
+  loadGrammarFromJson
+};
+//# sourceMappingURL=grammar-loader.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grammar-loader.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/grammar-loader.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 ******************************************************************************/\nimport { createDefaultCoreModule, createDefaultSharedCoreModule } from '../default-module.js';\nimport { inject } from '../dependency-injection.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { EmptyFileSystem } from '../workspace/file-system-provider.js';\nimport { URI } from './uri-utils.js';\nconst minimalGrammarModule = {\n    Grammar: () => undefined,\n    LanguageMetaData: () => ({\n        caseInsensitive: false,\n        fileExtensions: ['.langium'],\n        languageId: 'langium'\n    })\n};\nconst minimalSharedGrammarModule = {\n    AstReflection: () => new ast.LangiumGrammarAstReflection()\n};\nfunction createMinimalGrammarServices() {\n    const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);\n    const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);\n    shared.ServiceRegistry.register(grammar);\n    return grammar;\n}\n/**\n * Load a Langium grammar for your language from a JSON string. This is used by several services,\n * most notably the parser builder which interprets the grammar to create a parser.\n */\nexport function loadGrammarFromJson(json) {\n    var _a;\n    const services = createMinimalGrammarServices();\n    const astNode = services.serializer.JsonSerializer.deserialize(json);\n    services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : 'grammar'}.langium`));\n    return astNode;\n}\n//# sourceMappingURL=grammar-loader.js.map"],"names":["ast.LangiumGrammarAstReflection"],"mappings":";;;;;;AAUA,MAAM,uBAAuB;AAAA,EACzB,SAAS,MAAM;AAAA,EACf,kBAAkB,OAAO;AAAA,IACrB,iBAAiB;AAAA,IACjB,gBAAgB,CAAC,UAAU;AAAA,IAC3B,YAAY;AAAA,EACpB;AACA;AACA,MAAM,6BAA6B;AAAA,EAC/B,eAAe,MAAM,IAAIA,4BAA+B;AAC5D;AACA,SAAS,+BAA+B;AACpC,QAAM,SAAS,OAAO,8BAA8B,eAAe,GAAG,0BAA0B;AAChG,QAAM,UAAU,OAAO,wBAAwB,EAAE,OAAM,CAAE,GAAG,oBAAoB;AAChF,SAAO,gBAAgB,SAAS,OAAO;AACvC,SAAO;AACX;AAKO,SAAS,oBAAoB,MAAM;AACtC,MAAI;AACJ,QAAM,WAAW,6BAA4B;AAC7C,QAAM,UAAU,SAAS,WAAW,eAAe,YAAY,IAAI;AACnE,WAAS,OAAO,UAAU,uBAAuB,UAAU,SAAS,IAAI,MAAM,aAAa,KAAK,QAAQ,UAAU,QAAQ,OAAO,SAAS,KAAK,SAAS,UAAU,CAAC;AACnK,SAAO;AACX;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,378 @@
+import { assertUnreachable } from "./errors.mjs";
+import { isTerminalRule, isInferredType, isAction, isParserRule, isInterface, isType, isRuleCall, isTerminalAlternatives, isTerminalGroup, isCharacterRange, isTerminalRuleCall, isNegatedToken, isUntilToken, isRegexToken, isWildcard, isAssignment, isSimpleType, isKeyword, isReturnType } from "../languages/generated/ast.mjs";
+import { isCompositeCstNode } from "../syntax-tree.mjs";
+import { streamAllContents, getContainerOfType } from "./ast-utils.mjs";
+import { streamCst } from "./cst-utils.mjs";
+import { escapeRegExp, isWhitespace } from "./regexp-utils.mjs";
+function getEntryRule(grammar) {
+  return grammar.rules.find((e) => isParserRule(e) && e.entry);
+}
+function getHiddenRules(grammar) {
+  return grammar.rules.filter((e) => isTerminalRule(e) && e.hidden);
+}
+function getAllReachableRules(grammar, allTerminals) {
+  const ruleNames = /* @__PURE__ */ new Set();
+  const entryRule = getEntryRule(grammar);
+  if (!entryRule) {
+    return new Set(grammar.rules);
+  }
+  const topMostRules = [entryRule].concat(getHiddenRules(grammar));
+  for (const rule of topMostRules) {
+    ruleDfs(rule, ruleNames, allTerminals);
+  }
+  const rules = /* @__PURE__ */ new Set();
+  for (const rule of grammar.rules) {
+    if (ruleNames.has(rule.name) || isTerminalRule(rule) && rule.hidden) {
+      rules.add(rule);
+    }
+  }
+  return rules;
+}
+function ruleDfs(rule, visitedSet, allTerminals) {
+  visitedSet.add(rule.name);
+  streamAllContents(rule).forEach((node) => {
+    if (isRuleCall(node) || allTerminals) {
+      const refRule = node.rule.ref;
+      if (refRule && !visitedSet.has(refRule.name)) {
+        ruleDfs(refRule, visitedSet, allTerminals);
+      }
+    }
+  });
+}
+function getCrossReferenceTerminal(crossRef) {
+  if (crossRef.terminal) {
+    return crossRef.terminal;
+  } else if (crossRef.type.ref) {
+    const nameAssigment = findNameAssignment(crossRef.type.ref);
+    return nameAssigment === null || nameAssigment === void 0 ? void 0 : nameAssigment.terminal;
+  }
+  return void 0;
+}
+function isCommentTerminal(terminalRule) {
+  return terminalRule.hidden && !isWhitespace(terminalRegex(terminalRule));
+}
+function findNodesForProperty(node, property) {
+  if (!node || !property) {
+    return [];
+  }
+  return findNodesForPropertyInternal(node, property, node.astNode, true);
+}
+function findNodeForProperty(node, property, index) {
+  if (!node || !property) {
+    return void 0;
+  }
+  const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  if (index !== void 0) {
+    index = Math.max(0, Math.min(index, nodes.length - 1));
+  } else {
+    index = 0;
+  }
+  return nodes[index];
+}
+function findNodesForPropertyInternal(node, property, element, first) {
+  if (!first) {
+    const nodeFeature = getContainerOfType(node.grammarSource, isAssignment);
+    if (nodeFeature && nodeFeature.feature === property) {
+      return [node];
+    }
+  }
+  if (isCompositeCstNode(node) && node.astNode === element) {
+    return node.content.flatMap((e) => findNodesForPropertyInternal(e, property, element, false));
+  }
+  return [];
+}
+function findNodeForKeyword(node, keyword, index) {
+  if (!node) {
+    return void 0;
+  }
+  const nodes = findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  if (index !== void 0) {
+    index = Math.max(0, Math.min(index, nodes.length - 1));
+  } else {
+    index = 0;
+  }
+  return nodes[index];
+}
+function findNodesForKeywordInternal(node, keyword, element) {
+  if (node.astNode !== element) {
+    return [];
+  }
+  if (isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {
+    return [node];
+  }
+  const treeIterator = streamCst(node).iterator();
+  let result;
+  const keywordNodes = [];
+  do {
+    result = treeIterator.next();
+    if (!result.done) {
+      const childNode = result.value;
+      if (childNode.astNode === element) {
+        if (isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {
+          keywordNodes.push(childNode);
+        }
+      } else {
+        treeIterator.prune();
+      }
+    }
+  } while (!result.done);
+  return keywordNodes;
+}
+function findAssignment(cstNode) {
+  var _a;
+  const astNode = cstNode.astNode;
+  while (astNode === ((_a = cstNode.container) === null || _a === void 0 ? void 0 : _a.astNode)) {
+    const assignment = getContainerOfType(cstNode.grammarSource, isAssignment);
+    if (assignment) {
+      return assignment;
+    }
+    cstNode = cstNode.container;
+  }
+  return void 0;
+}
+function findNameAssignment(type) {
+  let startNode = type;
+  if (isInferredType(startNode)) {
+    if (isAction(startNode.$container)) {
+      startNode = startNode.$container.$container;
+    } else if (isParserRule(startNode.$container)) {
+      startNode = startNode.$container;
+    } else {
+      assertUnreachable(startNode.$container);
+    }
+  }
+  return findNameAssignmentInternal(type, startNode, /* @__PURE__ */ new Map());
+}
+function findNameAssignmentInternal(type, startNode, cache) {
+  var _a;
+  function go(node, refType) {
+    let childAssignment = void 0;
+    const parentAssignment = getContainerOfType(node, isAssignment);
+    if (!parentAssignment) {
+      childAssignment = findNameAssignmentInternal(refType, refType, cache);
+    }
+    cache.set(type, childAssignment);
+    return childAssignment;
+  }
+  if (cache.has(type)) {
+    return cache.get(type);
+  }
+  cache.set(type, void 0);
+  for (const node of streamAllContents(startNode)) {
+    if (isAssignment(node) && node.feature.toLowerCase() === "name") {
+      cache.set(type, node);
+      return node;
+    } else if (isRuleCall(node) && isParserRule(node.rule.ref)) {
+      return go(node, node.rule.ref);
+    } else if (isSimpleType(node) && ((_a = node.typeRef) === null || _a === void 0 ? void 0 : _a.ref)) {
+      return go(node, node.typeRef.ref);
+    }
+  }
+  return void 0;
+}
+function isDataTypeRule(rule) {
+  return isDataTypeRuleInternal(rule, /* @__PURE__ */ new Set());
+}
+function isDataTypeRuleInternal(rule, visited) {
+  if (visited.has(rule)) {
+    return true;
+  } else {
+    visited.add(rule);
+  }
+  for (const node of streamAllContents(rule)) {
+    if (isRuleCall(node)) {
+      if (!node.rule.ref) {
+        return false;
+      }
+      if (isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {
+        return false;
+      }
+    } else if (isAssignment(node)) {
+      return false;
+    } else if (isAction(node)) {
+      return false;
+    }
+  }
+  return Boolean(rule.definition);
+}
+function getExplicitRuleType(rule) {
+  if (rule.inferredType) {
+    return rule.inferredType.name;
+  } else if (rule.dataType) {
+    return rule.dataType;
+  } else if (rule.returnType) {
+    const refType = rule.returnType.ref;
+    if (refType) {
+      if (isParserRule(refType)) {
+        return refType.name;
+      } else if (isInterface(refType) || isType(refType)) {
+        return refType.name;
+      }
+    }
+  }
+  return void 0;
+}
+function getTypeName(type) {
+  var _a;
+  if (isParserRule(type)) {
+    return isDataTypeRule(type) ? type.name : (_a = getExplicitRuleType(type)) !== null && _a !== void 0 ? _a : type.name;
+  } else if (isInterface(type) || isType(type) || isReturnType(type)) {
+    return type.name;
+  } else if (isAction(type)) {
+    const actionType = getActionType(type);
+    if (actionType) {
+      return actionType;
+    }
+  } else if (isInferredType(type)) {
+    return type.name;
+  }
+  throw new Error("Cannot get name of Unknown Type");
+}
+function getActionType(action) {
+  var _a;
+  if (action.inferredType) {
+    return action.inferredType.name;
+  } else if ((_a = action.type) === null || _a === void 0 ? void 0 : _a.ref) {
+    return getTypeName(action.type.ref);
+  }
+  return void 0;
+}
+function getRuleType(rule) {
+  var _a, _b, _c;
+  if (isTerminalRule(rule)) {
+    return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "string";
+  } else {
+    return (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;
+  }
+}
+function terminalRegex(terminalRule) {
+  const flags = {
+    s: false,
+    i: false,
+    u: false
+  };
+  const source = abstractElementToRegex(terminalRule.definition, flags);
+  const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join("");
+  return new RegExp(source, flagText);
+}
+const WILDCARD = /[\s\S]/.source;
+function abstractElementToRegex(element, flags) {
+  if (isTerminalAlternatives(element)) {
+    return terminalAlternativesToRegex(element);
+  } else if (isTerminalGroup(element)) {
+    return terminalGroupToRegex(element);
+  } else if (isCharacterRange(element)) {
+    return characterRangeToRegex(element);
+  } else if (isTerminalRuleCall(element)) {
+    const rule = element.rule.ref;
+    if (!rule) {
+      throw new Error("Missing rule reference.");
+    }
+    return withCardinality(abstractElementToRegex(rule.definition), {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead
+    });
+  } else if (isNegatedToken(element)) {
+    return negateTokenToRegex(element);
+  } else if (isUntilToken(element)) {
+    return untilTokenToRegex(element);
+  } else if (isRegexToken(element)) {
+    const lastSlash = element.regex.lastIndexOf("/");
+    const source = element.regex.substring(1, lastSlash);
+    const regexFlags = element.regex.substring(lastSlash + 1);
+    if (flags) {
+      flags.i = regexFlags.includes("i");
+      flags.s = regexFlags.includes("s");
+      flags.u = regexFlags.includes("u");
+    }
+    return withCardinality(source, {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead,
+      wrap: false
+    });
+  } else if (isWildcard(element)) {
+    return withCardinality(WILDCARD, {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead
+    });
+  } else {
+    throw new Error(`Invalid terminal element: ${element === null || element === void 0 ? void 0 : element.$type}`);
+  }
+}
+function terminalAlternativesToRegex(alternatives) {
+  return withCardinality(alternatives.elements.map((e) => abstractElementToRegex(e)).join("|"), {
+    cardinality: alternatives.cardinality,
+    lookahead: alternatives.lookahead
+  });
+}
+function terminalGroupToRegex(group) {
+  return withCardinality(group.elements.map((e) => abstractElementToRegex(e)).join(""), {
+    cardinality: group.cardinality,
+    lookahead: group.lookahead
+  });
+}
+function untilTokenToRegex(until) {
+  return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {
+    cardinality: until.cardinality,
+    lookahead: until.lookahead
+  });
+}
+function negateTokenToRegex(negate) {
+  return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {
+    cardinality: negate.cardinality,
+    lookahead: negate.lookahead
+  });
+}
+function characterRangeToRegex(range) {
+  if (range.right) {
+    return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {
+      cardinality: range.cardinality,
+      lookahead: range.lookahead,
+      wrap: false
+    });
+  }
+  return withCardinality(keywordToRegex(range.left), {
+    cardinality: range.cardinality,
+    lookahead: range.lookahead,
+    wrap: false
+  });
+}
+function keywordToRegex(keyword) {
+  return escapeRegExp(keyword.value);
+}
+function withCardinality(regex, options) {
+  var _a;
+  if (options.wrap !== false || options.lookahead) {
+    regex = `(${(_a = options.lookahead) !== null && _a !== void 0 ? _a : ""}${regex})`;
+  }
+  if (options.cardinality) {
+    return `${regex}${options.cardinality}`;
+  }
+  return regex;
+}
+export {
+  findAssignment,
+  findNameAssignment,
+  findNodeForKeyword,
+  findNodeForProperty,
+  findNodesForKeywordInternal,
+  findNodesForProperty,
+  getActionType,
+  getAllReachableRules,
+  getCrossReferenceTerminal,
+  getEntryRule,
+  getExplicitRuleType,
+  getHiddenRules,
+  getRuleType,
+  getTypeName,
+  isCommentTerminal,
+  isDataTypeRule,
+  terminalRegex
+};
+//# sourceMappingURL=grammar-utils.mjs.map