@xlr-lib/xlr-utils 0.2.0--canary.2.120 → 1.0.0

package/dist/cjs/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/index.ts
@@ -33,223 +23,32 @@ __export(src_exports, {
   applyExcludeToNodeType: () => applyExcludeToNodeType,
   applyPartialOrRequiredToNodeType: () => applyPartialOrRequiredToNodeType,
   applyPickOrOmitToNodeType: () => applyPickOrOmitToNodeType,
-  buildTemplateRegex: () => buildTemplateRegex,
   computeEffectiveObject: () => computeEffectiveObject,
   computeExtends: () => computeExtends,
-  createDocString: () => createDocString,
-  createTSDocString: () => createTSDocString,
-  decorateNode: () => decorateNode,
   fillInGenerics: () => fillInGenerics,
-  getReferencedType: () => getReferencedType,
-  getStringLiteralsFromUnion: () => getStringLiteralsFromUnion,
   isAndType: () => isAndType,
   isArrayType: () => isArrayType,
   isBooleanType: () => isBooleanType,
-  isExportedDeclaration: () => isExportedDeclaration,
-  isGenericInterfaceDeclaration: () => isGenericInterfaceDeclaration,
   isGenericNamedType: () => isGenericNamedType,
   isGenericNodeType: () => isGenericNodeType,
-  isGenericTypeDeclaration: () => isGenericTypeDeclaration,
   isNamedType: () => isNamedType,
   isNode: () => isNode,
-  isNodeExported: () => isNodeExported,
   isNonNullable: () => isNonNullable,
   isNumberType: () => isNumberType,
   isObjectType: () => isObjectType,
-  isOptionalProperty: () => isOptionalProperty,
   isOrType: () => isOrType,
   isPrimitiveTypeNode: () => isPrimitiveTypeNode,
   isRecordType: () => isRecordType,
   isRefType: () => isRefType,
   isStringType: () => isStringType,
-  isTopLevelDeclaration: () => isTopLevelDeclaration,
-  isTopLevelNode: () => isTopLevelNode,
-  isTypeReferenceGeneric: () => isTypeReferenceGeneric,
-  isTypeScriptLibType: () => isTypeScriptLibType,
   makePropertyMap: () => makePropertyMap,
   propertyToTuple: () => propertyToTuple,
   resolveConditional: () => resolveConditional,
-  resolveReferenceNode: () => resolveReferenceNode,
-  symbolDisplayToString: () => symbolDisplayToString,
-  tsStripOptionalType: () => tsStripOptionalType
+  resolveReferenceNode: () => resolveReferenceNode
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/annotations.ts
-var import_typescript = __toESM(require("typescript"));
-function extractDescription(text) {
-  if (!text) {
-    return {};
-  }
-  return { description: text };
-}
-function parentIsNonObjectPath(node) {
-  return node.parent && (import_typescript.default.isArrayTypeNode(node.parent) || import_typescript.default.isTupleTypeNode(node.parent) || import_typescript.default.isOptionalTypeNode(node.parent) || import_typescript.default.isRestTypeNode(node.parent) || import_typescript.default.isUnionTypeNode(node.parent));
-}
-function recurseTypeChain(node, child) {
-  if (!node) {
-    return [];
-  }
-  if (import_typescript.default.isArrayTypeNode(node) && node.parent && import_typescript.default.isRestTypeNode(node.parent)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isRestTypeNode(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isOptionalTypeNode(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isUnionTypeNode(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isParenthesizedTypeNode(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isTypeLiteralNode(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  if (import_typescript.default.isArrayTypeNode(node)) {
-    return ["[]", ...recurseTypeChain(node.parent, node)];
-  }
-  if (import_typescript.default.isTupleTypeNode(node)) {
-    const pos = node.elements.indexOf(child);
-    return [
-      ...pos === -1 ? [] : [`${pos}`],
-      ...recurseTypeChain(node.parent, node)
-    ];
-  }
-  if (import_typescript.default.isTypeAliasDeclaration(node) || import_typescript.default.isInterfaceDeclaration(node) || import_typescript.default.isPropertySignature(node)) {
-    return [node.name.getText(), ...recurseTypeChain(node.parent, node)];
-  }
-  if (parentIsNonObjectPath(node)) {
-    return recurseTypeChain(node.parent, node);
-  }
-  return [];
-}
-function extractTitle(node) {
-  const typeNames = recurseTypeChain(node, void 0).reverse().join(".");
-  if (!typeNames.length) {
-    return {};
-  }
-  return { title: typeNames };
-}
-function stringifyDoc(docString) {
-  if (typeof docString === "undefined" || typeof docString === "string") {
-    return docString;
-  }
-  return docString.map(({ text }) => text).join(" ");
-}
-function extractTags(tags) {
-  const descriptions = [];
-  const examples = [];
-  const _default = [];
-  const see = [];
-  const meta = {};
-  const extractSee = (tag) => {
-    return `${tag.tagName ? `${tag.tagName?.getText()} ` : ""}${stringifyDoc(tag.comment)?.trim() ?? ""}`;
-  };
-  tags.forEach((tag) => {
-    if (!tag.comment) {
-      return;
-    }
-    if (tag.tagName.text === "example") {
-      examples.push(stringifyDoc(tag.comment)?.trim() ?? "");
-    } else if (tag.tagName.text === "default") {
-      _default.push(stringifyDoc(tag.comment)?.trim() ?? "");
-    } else if (tag.tagName.text === "see") {
-      see.push(extractSee(tag));
-    } else if (tag.tagName.text === "meta") {
-      const [key, value] = tag.comment.toString().split(/:(.*)/);
-      meta[key] = value?.trim() ?? "";
-    } else {
-      const text = stringifyDoc(tag.comment)?.trim() ?? "";
-      descriptions.push(`@${tag.tagName.text} ${text}`);
-    }
-  });
-  return {
-    ...descriptions.length === 0 ? {} : { description: descriptions.join("\n") },
-    ...examples.length === 0 ? {} : { examples },
-    ..._default.length === 0 ? {} : { default: _default.join("\n") },
-    ...see.length === 0 ? {} : { see },
-    ...meta && Object.keys(meta).length === 0 ? {} : { meta }
-  };
-}
-function join(t, separator = "\n") {
-  const unique = new Set(t).values();
-  return Array.from(unique).filter((s) => s !== void 0).join(separator).trim();
-}
-function mergeAnnotations(nodes) {
-  const name = nodes.find((n) => n.name)?.name;
-  const title = join(
-    nodes.map((n) => n.title),
-    ", "
-  );
-  const description = join(nodes.map((n) => n.description));
-  const _default = join(nodes.map((n) => n.default));
-  const comment = join(nodes.map((n) => n.comment));
-  const examples = join(
-    nodes.map(
-      (n) => Array.isArray(n.examples) ? join(n.examples) : n.examples
-    )
-  );
-  const see = join(
-    nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see)
-  );
-  const meta = nodes.find((n) => n.meta)?.meta;
-  return {
-    ...name ? { name } : {},
-    ...title ? { title } : {},
-    ...description ? { description } : {},
-    ...examples ? { examples } : {},
-    ..._default ? { default: _default } : {},
-    ...see ? { see } : {},
-    ...comment ? { comment } : {},
-    ...meta ? { meta } : {}
-  };
-}
-function decorateNode(node) {
-  const { jsDoc } = node;
-  const titleAnnotation = extractTitle(node);
-  if (jsDoc && jsDoc.length) {
-    const first = jsDoc[0];
-    return mergeAnnotations([
-      extractDescription(stringifyDoc(first.comment)),
-      titleAnnotation,
-      extractTags(first.tags ?? [])
-    ]);
-  }
-  return titleAnnotation;
-}
-
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/ts-helpers.ts
-var import_typescript3 = __toESM(require("typescript"));
-
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/type-checks.ts
-var import_typescript2 = __toESM(require("typescript"));
-function isOptionalProperty(node) {
-  return node.questionToken?.kind === import_typescript2.default.SyntaxKind.QuestionToken;
-}
-function isGenericInterfaceDeclaration(node) {
-  const length = node.typeParameters?.length;
-  return length ? length > 0 : false;
-}
-function isGenericTypeDeclaration(node) {
-  const length = node.typeParameters?.length;
-  return length ? length > 0 : false;
-}
-function isTypeReferenceGeneric(node, typeChecker) {
-  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
-  if (symbol && symbol.declarations) {
-    return symbol.declarations[0].kind === import_typescript2.default.SyntaxKind.TypeParameter;
-  }
-  return false;
-}
-function isTopLevelDeclaration(node) {
-  return node.kind === import_typescript2.default.SyntaxKind.InterfaceDeclaration || node.kind === import_typescript2.default.SyntaxKind.TypeAliasDeclaration;
-}
-function isTopLevelNode(node) {
-  return node.kind === import_typescript2.default.SyntaxKind.InterfaceDeclaration || node.kind === import_typescript2.default.SyntaxKind.TypeAliasDeclaration || node.kind === import_typescript2.default.SyntaxKind.VariableStatement;
-}
 function isGenericNodeType(nt) {
   return nt.genericTokens?.length > 0;
 }
@@ -295,12 +94,8 @@ function isNamedType(node) {
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/validation-helpers.ts
 function propertyToTuple(node) {
-  let key = node.children?.[0].value;
-  if (key.includes("-")) {
-    key = `'${key}'`;
-  }
   return {
-    key,
+    key: node.children?.[0].value,
     value: node.children?.[1]
   };
 }
@@ -435,89 +230,20 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
   return newObject;
 }
 
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/ts-helpers.ts
-function tsStripOptionalType(node) {
-  return import_typescript3.default.isOptionalTypeNode(node) ? node.type : node;
-}
-function isExportedDeclaration(node) {
-  const modifiers = import_typescript3.default.canHaveModifiers(node) ? import_typescript3.default.getModifiers(node) : void 0;
-  if (modifiers) {
-    return modifiers.some((m) => m.kind === import_typescript3.default.SyntaxKind.ExportKeyword);
-  }
-  return false;
-}
-function isNodeExported(node) {
-  return (import_typescript3.default.getCombinedModifierFlags(node) & import_typescript3.default.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === import_typescript3.default.SyntaxKind.SourceFile;
-}
-function getReferencedType(node, typeChecker) {
-  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
-  if (symbol && (symbol.flags & import_typescript3.default.SymbolFlags.Alias) === import_typescript3.default.SymbolFlags.Alias) {
-    symbol = typeChecker.getAliasedSymbol(symbol);
-  }
-  const varDecl = symbol?.declarations?.[0];
-  if (varDecl && (import_typescript3.default.isInterfaceDeclaration(varDecl) || import_typescript3.default.isTypeAliasDeclaration(varDecl))) {
-    return { declaration: varDecl, exported: isNodeExported(varDecl) };
-  }
-}
-function isTypeScriptLibType(node, typeChecker) {
-  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
-  if (!symbol) return false;
-  if ((symbol.flags & import_typescript3.default.SymbolFlags.Alias) === import_typescript3.default.SymbolFlags.Alias) {
-    symbol = typeChecker.getAliasedSymbol(symbol);
-  }
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return false;
-  return declarations.some((decl) => {
-    const sourceFile = decl.getSourceFile();
-    if (!sourceFile) return false;
-    const filePath = sourceFile.fileName;
-    return filePath.includes("/typescript/lib/") || filePath.includes("\\typescript\\lib\\") || filePath.endsWith(".d.ts") && filePath.includes("lib.");
-  });
-}
-function getStringLiteralsFromUnion(node) {
-  if (import_typescript3.default.isUnionTypeNode(node)) {
-    return new Set(
-      node.types.map((type) => {
-        if (import_typescript3.default.isLiteralTypeNode(type) && import_typescript3.default.isStringLiteral(type.literal)) {
-          return type.literal.text;
-        }
-        return "";
-      })
-    );
-  }
-  if (import_typescript3.default.isLiteralTypeNode(node) && import_typescript3.default.isStringLiteral(node.literal)) {
-    return /* @__PURE__ */ new Set([node.literal.text]);
-  }
-  return /* @__PURE__ */ new Set();
-}
-function buildTemplateRegex(node, typeChecker) {
-  let regex = node.head.text;
-  node.templateSpans.forEach((span) => {
-    let type = span.type.kind;
-    if (import_typescript3.default.isTypeReferenceNode(span.type)) {
-      let symbol = typeChecker.getSymbolAtLocation(
-        span.type.typeName
-      );
-      if (symbol && (symbol.flags & import_typescript3.default.SymbolFlags.Alias) === import_typescript3.default.SymbolFlags.Alias) {
-        symbol = typeChecker.getAliasedSymbol(symbol);
-      }
-      type = (symbol?.declarations?.[0]).type.kind;
-    }
-    if (type === import_typescript3.default.SyntaxKind.StringKeyword) {
-      regex += ".*";
-    } else if (type === import_typescript3.default.SyntaxKind.NumberKeyword) {
-      regex += "[0-9]*";
-    } else if (type === import_typescript3.default.SyntaxKind.BooleanKeyword) {
-      regex += "true|false";
-    }
-    regex += span.literal.text;
-  });
-  return regex;
-}
-function fillInGenerics(xlrNode, generics) {
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/xlr-helpers.ts
+function fillInGenerics(xlrNode, generics, preferLocalGenerics = false) {
   let localGenerics;
   if (generics) {
     localGenerics = new Map(generics);
+    if (preferLocalGenerics && isGenericNodeType(xlrNode)) {
+      xlrNode.genericTokens?.forEach((token) => {
+        const genericValue = token.default ?? token.constraints;
+        localGenerics.set(
+          token.symbol,
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics)
+        );
+      });
+    }
   } else {
     localGenerics = /* @__PURE__ */ new Map();
     if (isGenericNodeType(xlrNode)) {
@@ -525,7 +251,7 @@ function fillInGenerics(xlrNode, generics) {
         const genericValue = token.default ?? token.constraints;
         localGenerics.set(
           token.symbol,
-          fillInGenerics(genericValue, localGenerics)
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics)
         );
       });
     }
@@ -536,7 +262,7 @@ function fillInGenerics(xlrNode, generics) {
         ...localGenerics.get(xlrNode.ref),
         ...xlrNode.genericArguments ? {
           genericArguments: xlrNode.genericArguments.map(
-            (ga) => fillInGenerics(ga, localGenerics)
+            (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
           )
         } : {},
         ...xlrNode.title ? { title: xlrNode.title } : {},
@@ -549,7 +275,7 @@ function fillInGenerics(xlrNode, generics) {
       ...xlrNode,
       ...xlrNode.genericArguments ? {
         genericArguments: xlrNode.genericArguments.map(
-          (ga) => fillInGenerics(ga, localGenerics)
+          (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
         )
       } : {}
     };
@@ -560,7 +286,7 @@ function fillInGenerics(xlrNode, generics) {
       const prop = xlrNode.properties[propName];
       newProperties[propName] = {
         required: prop.required,
-        node: fillInGenerics(prop.node, localGenerics)
+        node: fillInGenerics(prop.node, localGenerics, preferLocalGenerics)
       };
     });
     return {
@@ -570,19 +296,39 @@ function fillInGenerics(xlrNode, generics) {
         genericTokens: xlrNode.genericTokens.map((token) => {
           return {
             ...token,
-            constraints: token.constraints ? fillInGenerics(token.constraints, localGenerics) : void 0,
-            default: token.default ? fillInGenerics(token.default, localGenerics) : void 0
+            constraints: token.constraints ? fillInGenerics(
+              token.constraints,
+              localGenerics,
+              preferLocalGenerics
+            ) : void 0,
+            default: token.default ? fillInGenerics(
+              token.default,
+              localGenerics,
+              preferLocalGenerics
+            ) : void 0
           };
         })
       } : {},
-      extends: xlrNode.extends ? fillInGenerics(xlrNode.extends, localGenerics) : void 0,
-      additionalProperties: xlrNode.additionalProperties ? fillInGenerics(xlrNode.additionalProperties, localGenerics) : false
+      extends: xlrNode.extends ? fillInGenerics(
+        xlrNode.extends,
+        localGenerics,
+        preferLocalGenerics
+      ) : void 0,
+      additionalProperties: xlrNode.additionalProperties ? fillInGenerics(
+        xlrNode.additionalProperties,
+        localGenerics,
+        preferLocalGenerics
+      ) : false
     };
   }
   if (xlrNode.type === "array") {
     return {
       ...xlrNode,
-      elementType: fillInGenerics(xlrNode.elementType, localGenerics)
+      elementType: fillInGenerics(
+        xlrNode.elementType,
+        localGenerics,
+        preferLocalGenerics
+      )
     };
   } else if (xlrNode.type === "or" || xlrNode.type === "and") {
     let pointer;
@@ -594,25 +340,49 @@ function fillInGenerics(xlrNode, generics) {
     return {
       ...xlrNode,
       [xlrNode.type]: pointer.map((prop) => {
-        return fillInGenerics(prop, localGenerics);
+        return fillInGenerics(prop, localGenerics, preferLocalGenerics);
       })
     };
   } else if (xlrNode.type === "record") {
     return {
       ...xlrNode,
-      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
-      valueType: fillInGenerics(xlrNode.valueType, localGenerics)
+      keyType: fillInGenerics(
+        xlrNode.keyType,
+        localGenerics,
+        preferLocalGenerics
+      ),
+      valueType: fillInGenerics(
+        xlrNode.valueType,
+        localGenerics,
+        preferLocalGenerics
+      )
     };
   } else if (xlrNode.type === "conditional") {
     const filledInConditional = {
       ...xlrNode,
       check: {
-        left: fillInGenerics(xlrNode.check.left, localGenerics),
-        right: fillInGenerics(xlrNode.check.right, localGenerics)
+        left: fillInGenerics(
+          xlrNode.check.left,
+          localGenerics,
+          preferLocalGenerics
+        ),
+        right: fillInGenerics(
+          xlrNode.check.right,
+          localGenerics,
+          preferLocalGenerics
+        )
       },
       value: {
-        true: fillInGenerics(xlrNode.value.true, localGenerics),
-        false: fillInGenerics(xlrNode.value.false, localGenerics)
+        true: fillInGenerics(
+          xlrNode.value.true,
+          localGenerics,
+          preferLocalGenerics
+        ),
+        false: fillInGenerics(
+          xlrNode.value.false,
+          localGenerics,
+          preferLocalGenerics
+        )
       }
     };
     if (filledInConditional.check.left.type !== "ref" && filledInConditional.check.right.type !== "ref") {
@@ -706,250 +476,32 @@ function applyExcludeToNodeType(baseObject, filters) {
     or: remainingMembers
   };
 }
-
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/documentation.ts
-var import_typescript4 = __toESM(require("typescript"));
-var { SymbolDisplayPartKind, displayPartsToString } = import_typescript4.default;
-function insertBetweenElements(array, separator) {
-  return array.reduce((acc, item, index) => {
-    if (index === 0) {
-      return [item];
-    }
-    return [...acc, separator, item];
-  }, []);
-}
-function createTSDocString(node) {
-  if (node.type === "ref") {
-    return [
-      {
-        text: node.ref,
-        kind: SymbolDisplayPartKind.keyword
-      }
-    ];
-  }
-  if (node.type === "or" || node.type === "and") {
-    const items = node.type === "and" ? node.and : node.or;
-    return insertBetweenElements(
-      items.map((subnode) => createTSDocString(subnode)),
-      [
-        {
-          kind: SymbolDisplayPartKind.punctuation,
-          text: node.type === "and" ? " & " : " | "
-        }
-      ]
-    ).flat();
-  }
-  if (node.type === "function") {
-    return [
-      {
-        kind: SymbolDisplayPartKind.keyword,
-        text: "function"
-      },
-      {
-        kind: SymbolDisplayPartKind.space,
-        text: " "
-      },
-      ...node.name ? [{ text: node.name, kind: SymbolDisplayPartKind.methodName }] : [],
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: "("
-      },
-      ...insertBetweenElements(
-        node.parameters.map((p) => {
-          if (p.name) {
-            return [
-              {
-                kind: SymbolDisplayPartKind.parameterName,
-                text: p.name
-              },
-              {
-                kind: SymbolDisplayPartKind.punctuation,
-                text: p.optional ? "?" : ""
-              },
-              {
-                kind: SymbolDisplayPartKind.punctuation,
-                text: ": "
-              },
-              ...createTSDocString(p.type)
-            ];
-          }
-          return createTSDocString(p.type);
-        }),
-        [
-          {
-            kind: SymbolDisplayPartKind.punctuation,
-            text: ", "
-          }
-        ]
-      ).flat(),
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: ")"
-      },
-      ...node.returnType ? [
-        {
-          kind: SymbolDisplayPartKind.punctuation,
-          text: ": "
-        },
-        ...createTSDocString(node.returnType)
-      ] : []
-    ];
-  }
-  if (node.type === "tuple") {
-    return [
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: "["
-      },
-      ...insertBetweenElements(
-        node.elementTypes.map((t) => {
-          if (t.name) {
-            return [
-              {
-                kind: SymbolDisplayPartKind.propertyName,
-                text: t.name
-              },
-              {
-                kind: SymbolDisplayPartKind.punctuation,
-                text: ": "
-              },
-              ...createTSDocString(t.type)
-            ];
-          }
-          return createTSDocString(t.type);
-        }),
-        [
-          {
-            kind: SymbolDisplayPartKind.punctuation,
-            text: ", "
-          }
-        ]
-      ).flat(),
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: "]"
-      }
-    ];
-  }
-  if (node.type === "array") {
-    return [
-      {
-        kind: SymbolDisplayPartKind.interfaceName,
-        text: "Array"
-      },
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: "<"
-      },
-      ...createTSDocString(node.elementType),
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: ">"
-      }
-    ];
-  }
-  if (node.type === "record") {
-    return [
-      {
-        kind: SymbolDisplayPartKind.interfaceName,
-        text: "Record"
-      },
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: "<"
-      },
-      ...createTSDocString(node.keyType),
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: ", "
-      },
-      ...createTSDocString(node.valueType),
-      {
-        kind: SymbolDisplayPartKind.punctuation,
-        text: ">"
-      }
-    ];
-  }
-  if ((node.type === "string" || node.type === "boolean" || node.type === "number") && node.const !== void 0) {
-    return [
-      {
-        kind: SymbolDisplayPartKind.keyword,
-        text: typeof node.const === "string" ? `"${node.const}"` : String(node.const)
-      }
-    ];
-  }
-  if (isPrimitiveTypeNode(node) && node.type !== "null") {
-    return [
-      {
-        kind: SymbolDisplayPartKind.keyword,
-        text: node.type
-      }
-    ];
-  }
-  if (node.type === "object" && node.name) {
-    return [
-      {
-        kind: SymbolDisplayPartKind.interfaceName,
-        text: node.name
-      }
-    ];
-  }
-  return [
-    {
-      kind: SymbolDisplayPartKind.localName,
-      text: node.type
-    }
-  ];
-}
-function symbolDisplayToString(displayParts) {
-  return displayPartsToString(displayParts);
-}
-function createDocString(node) {
-  return symbolDisplayToString(createTSDocString(node));
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   applyExcludeToNodeType,
   applyPartialOrRequiredToNodeType,
   applyPickOrOmitToNodeType,
-  buildTemplateRegex,
   computeEffectiveObject,
   computeExtends,
-  createDocString,
-  createTSDocString,
-  decorateNode,
   fillInGenerics,
-  getReferencedType,
-  getStringLiteralsFromUnion,
   isAndType,
   isArrayType,
   isBooleanType,
-  isExportedDeclaration,
-  isGenericInterfaceDeclaration,
   isGenericNamedType,
   isGenericNodeType,
-  isGenericTypeDeclaration,
   isNamedType,
   isNode,
-  isNodeExported,
   isNonNullable,
   isNumberType,
   isObjectType,
-  isOptionalProperty,
   isOrType,
   isPrimitiveTypeNode,
   isRecordType,
   isRefType,
   isStringType,
-  isTopLevelDeclaration,
-  isTopLevelNode,
-  isTypeReferenceGeneric,
-  isTypeScriptLibType,
   makePropertyMap,
   propertyToTuple,
   resolveConditional,
-  resolveReferenceNode,
-  symbolDisplayToString,
-  tsStripOptionalType
+  resolveReferenceNode
 });
 //# sourceMappingURL=index.cjs.map