qidian-vue-ui 1.1.55 → 1.1.57

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

@@ -1,127 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,34 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,378 +0,0 @@
-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