@xlr-lib/xlr-converters 0.1.1--canary.9.190

package/dist/index.legacy-esm.js

@@ -0,0 +1,1703 @@
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
+import ts3 from "typescript";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-utils.ts
+import ts from "typescript";
+function isOptionalProperty(node) {
+  return node.questionToken?.kind === ts.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 === ts.SyntaxKind.TypeParameter;
+  }
+  return false;
+}
+function isTopLevelDeclaration(node) {
+  return node.kind === ts.SyntaxKind.InterfaceDeclaration || node.kind === ts.SyntaxKind.TypeAliasDeclaration;
+}
+function isTopLevelNode(node) {
+  return node.kind === ts.SyntaxKind.InterfaceDeclaration || node.kind === ts.SyntaxKind.TypeAliasDeclaration || node.kind === ts.SyntaxKind.VariableStatement;
+}
+function tsStripOptionalType(node) {
+  return ts.isOptionalTypeNode(node) ? node.type : node;
+}
+function isExportedDeclaration(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  if (modifiers) {
+    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+  }
+  return false;
+}
+function isNodeExported(node) {
+  return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts.SyntaxKind.SourceFile;
+}
+function getReferencedType(node, typeChecker) {
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && (symbol.flags & ts.SymbolFlags.Alias) === ts.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const varDecl = symbol?.declarations?.[0];
+  if (varDecl && (ts.isInterfaceDeclaration(varDecl) || ts.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 & ts.SymbolFlags.Alias) === ts.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 (ts.isUnionTypeNode(node)) {
+    return new Set(
+      node.types.map((type) => {
+        if (ts.isLiteralTypeNode(type) && ts.isStringLiteral(type.literal)) {
+          return type.literal.text;
+        }
+        return "";
+      })
+    );
+  }
+  if (ts.isLiteralTypeNode(node) && ts.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 (ts.isTypeReferenceNode(span.type)) {
+      let symbol = typeChecker.getSymbolAtLocation(
+        span.type.typeName
+      );
+      if (symbol && (symbol.flags & ts.SymbolFlags.Alias) === ts.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      type = (symbol?.declarations?.[0]).type.kind;
+    }
+    if (type === ts.SyntaxKind.StringKeyword) {
+      regex += ".*";
+    } else if (type === ts.SyntaxKind.NumberKeyword) {
+      regex += "[0-9]*";
+    } else if (type === ts.SyntaxKind.BooleanKeyword) {
+      regex += "true|false";
+    }
+    regex += span.literal.text;
+  });
+  return regex;
+}
+function isExportedModuleDeclaration(node) {
+  return isExportedDeclaration(node) && ts.isModuleDeclaration(node);
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/annotations.ts
+import ts2 from "typescript";
+function extractDescription(text) {
+  if (!text) {
+    return {};
+  }
+  return { description: text };
+}
+function parentIsNonObjectPath(node) {
+  return node.parent && (ts2.isArrayTypeNode(node.parent) || ts2.isTupleTypeNode(node.parent) || ts2.isOptionalTypeNode(node.parent) || ts2.isRestTypeNode(node.parent) || ts2.isUnionTypeNode(node.parent));
+}
+function recurseTypeChain(node, child) {
+  if (!node) {
+    return [];
+  }
+  if (ts2.isArrayTypeNode(node) && node.parent && ts2.isRestTypeNode(node.parent)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isRestTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isOptionalTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isUnionTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isParenthesizedTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isTypeLiteralNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts2.isArrayTypeNode(node)) {
+    return ["[]", ...recurseTypeChain(node.parent, node)];
+  }
+  if (ts2.isTupleTypeNode(node)) {
+    const pos = node.elements.indexOf(child);
+    return [
+      ...pos === -1 ? [] : [`${pos}`],
+      ...recurseTypeChain(node.parent, node)
+    ];
+  }
+  if (ts2.isTypeAliasDeclaration(node) || ts2.isInterfaceDeclaration(node) || ts2.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/converters/src/ts/ts-to-xlr.ts
+import {
+  fillInGenerics,
+  isNonNullable,
+  applyPartialOrRequiredToNodeType,
+  applyPickOrOmitToNodeType,
+  applyExcludeToNodeType,
+  isGenericNodeType,
+  resolveConditional,
+  isPrimitiveTypeNode
+} from "@xlr-lib/xlr-utils";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/types.ts
+var ConversionError = class _ConversionError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, _ConversionError.prototype);
+  }
+  toString() {
+    return `Conversion Error: ${this.message}`;
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
+function isMappedTypeNode(x) {
+  return ["Pick", "Omit", "Required", "Partial", "Exclude"].includes(x);
+}
+function getPropertyNameText(name) {
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return name.getText();
+}
+var AnyTypeNode = {
+  type: "any"
+};
+var TsConverter = class {
+  context;
+  constructor(typeChecker, customPrimitives) {
+    this.context = {
+      customPrimitives: customPrimitives ?? [],
+      typeChecker,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      },
+      cache: {
+        convertedNodes: /* @__PURE__ */ new Map(),
+        convertedTemplates: /* @__PURE__ */ new Map()
+      }
+    };
+  }
+  /** Converts all exported objects to a XLR representation */
+  convertSourceFile(sourceFile) {
+    const declarations = sourceFile.statements.filter(isTopLevelNode);
+    const namespacedTypes = sourceFile.statements.filter((s) => isExportedModuleDeclaration(s)).flatMap((module) => {
+      if (module.body && ts3.isModuleBlock(module.body)) {
+        const nameSpaceName = module.name.text;
+        return module.body.statements.filter(isExportedDeclaration).filter(isTopLevelNode).map((statement) => {
+          const convertedNode = this.convertTopLevelNode(statement);
+          return {
+            ...convertedNode,
+            name: `${nameSpaceName}.${convertedNode.name}`
+          };
+        });
+      }
+      return [];
+    });
+    const types = declarations.filter((declaration) => isExportedDeclaration(declaration)).map((statement) => this.convertTopLevelNode(statement)).filter((v) => !!v);
+    types.push(...namespacedTypes);
+    return {
+      data: { version: 1, types },
+      convertedTypes: types.map(({ name }) => name)
+    };
+  }
+  convertTopLevelNode(node) {
+    const sourceFile = node.parent;
+    const { fileName } = sourceFile;
+    if (ts3.isVariableStatement(node)) {
+      return {
+        source: fileName,
+        ...this.convertVariable(node)
+      };
+    }
+    return {
+      source: fileName,
+      ...this.convertDeclaration(node)
+    };
+  }
+  /** Converts a single type/interface declaration to XLRs */
+  convertDeclaration(node) {
+    if (ts3.isTypeAliasDeclaration(node)) {
+      let genericTokens;
+      if (isGenericTypeDeclaration(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      return {
+        name: node.name.getText(),
+        ...this.convertTsTypeNode(node.type) ?? AnyTypeNode,
+        ...decorateNode(node),
+        genericTokens
+      };
+    }
+    if (ts3.isInterfaceDeclaration(node)) {
+      let genericTokens;
+      if (isGenericInterfaceDeclaration(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      const baseObject = {
+        name: node.name.getText(),
+        type: "object",
+        ...this.tsObjectMembersToProperties(node),
+        ...decorateNode(node),
+        genericTokens
+      };
+      if (node.heritageClauses) {
+        return this.handleHeritageClauses(
+          node.heritageClauses,
+          baseObject,
+          this.context.typeChecker
+        );
+      }
+      return baseObject;
+    }
+    this.context.throwError(
+      `Error: type node is not an Interface or a Type, can't convert as Declaration`
+    );
+  }
+  convertVariable(node) {
+    const variableDeclarations = node.declarationList.declarations;
+    if (variableDeclarations.length === 1) {
+      const variable = variableDeclarations[0];
+      if (variable.initializer) {
+        let resultingNode;
+        if (variable.type && ts3.isTypeReferenceNode(variable.type) && ts3.isIdentifier(variable.type.typeName) && this.context.customPrimitives.includes(variable.type.typeName.text)) {
+          resultingNode = this.makeBasicRefNode(variable.type);
+        } else if (ts3.isCallExpression(variable.initializer) || ts3.isArrowFunction(variable.initializer)) {
+          resultingNode = this.resolveFunctionCall(
+            variable.initializer,
+            node.parent
+          );
+        } else {
+          resultingNode = this.tsLiteralToType(variable.initializer);
+        }
+        if (resultingNode.type === "function" || resultingNode.type === "ref") {
+          resultingNode = { ...resultingNode, name: variable.name.getText() };
+        }
+        return {
+          name: variable.name.getText(),
+          ...resultingNode
+        };
+      }
+    }
+    this.context.throwError(
+      `Error: Multi-variable declaration on line ${node.pos} is not supported for conversion`
+    );
+  }
+  /** Converts an arbitrary ts.TypeNode to XLRs */
+  convertTsTypeNode(node) {
+    if (this.context.cache.convertedNodes.has(node)) {
+      const cachedType = this.context.cache.convertedNodes.get(
+        node
+      );
+      return JSON.parse(JSON.stringify(cachedType));
+    }
+    const convertedNode = this.tsNodeToType(node);
+    this.context.cache.convertedNodes.set(node, convertedNode);
+    return convertedNode;
+  }
+  /** Should not be called directly unless you want to bypass the cache, use `convertTsTypeNode` */
+  tsNodeToType(node) {
+    if (ts3.isUnionTypeNode(node)) {
+      return {
+        type: "or",
+        or: node.types.map((child) => this.convertTsTypeNode(child)).filter(isNonNullable),
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isIntersectionTypeNode(node)) {
+      return {
+        type: "and",
+        and: node.types.map((child) => this.convertTsTypeNode(child)).filter(isNonNullable),
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isParenthesizedTypeNode(node)) {
+      const children = [];
+      node.forEachChild((child) => {
+        children.push(child);
+      });
+      if (children[0]?.kind === ts3.SyntaxKind.OpenParenToken) {
+        children.shift();
+      }
+      if (children[children.length - 1]?.kind === ts3.SyntaxKind.CloseParenToken) {
+        children.pop();
+      }
+      const element = children[0];
+      if (children.length !== 1 || !ts3.isTypeNode(element)) {
+        this.context.throwError(
+          `Parenthesis type not understood. Length ${children.length}, Is Type Node: ${ts3.SyntaxKind[element.kind]}`
+        );
+      }
+      return this.convertTsTypeNode(element);
+    }
+    if (node.kind === ts3.SyntaxKind.AnyKeyword) {
+      return { type: "any", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.UnknownKeyword) {
+      return { type: "unknown", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.StringKeyword) {
+      return { type: "string", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.NumberKeyword) {
+      return { type: "number", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.BooleanKeyword) {
+      return { type: "boolean", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.UndefinedKeyword) {
+      return { type: "undefined", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.NeverKeyword) {
+      return { type: "never", ...decorateNode(node) };
+    }
+    if (node.kind === ts3.SyntaxKind.ObjectKeyword) {
+      return {
+        type: "object",
+        properties: {},
+        additionalProperties: AnyTypeNode,
+        ...decorateNode(node)
+      };
+    }
+    if (node.kind === ts3.SyntaxKind.VoidKeyword) {
+      return {
+        type: "void",
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isTemplateLiteralTypeNode(node)) {
+      let format;
+      if (this.context.cache.convertedTemplates.has(node)) {
+        format = this.context.cache.convertedTemplates.get(node);
+      } else {
+        format = buildTemplateRegex(node, this.context.typeChecker);
+        this.context.cache.convertedTemplates.set(node, format);
+      }
+      return {
+        type: "template",
+        format
+      };
+    }
+    if (ts3.isArrayTypeNode(node)) {
+      return {
+        type: "array",
+        elementType: this.convertTsTypeNode(node.elementType) ?? AnyTypeNode,
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isConditionalTypeNode(node)) {
+      const xlrNode = {
+        type: "conditional",
+        check: {
+          left: this.convertTsTypeNode(node.checkType),
+          right: this.convertTsTypeNode(node.extendsType)
+        },
+        value: {
+          true: this.convertTsTypeNode(node.trueType),
+          false: this.convertTsTypeNode(node.falseType)
+        }
+      };
+      if (isPrimitiveTypeNode(xlrNode.check.left) && isPrimitiveTypeNode(xlrNode.check.right)) {
+        return resolveConditional(xlrNode);
+      } else {
+        return xlrNode;
+      }
+    }
+    if (ts3.isTypeReferenceNode(node)) {
+      return this.resolveRefNode(node);
+    }
+    if (ts3.isTupleTypeNode(node)) {
+      return {
+        type: "tuple",
+        ...this.tsTupleToType(node),
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isLiteralTypeNode(node)) {
+      return this.tsLiteralToType(node.literal);
+    }
+    if (ts3.isTypeLiteralNode(node)) {
+      return {
+        type: "object",
+        ...this.tsObjectMembersToProperties(node),
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isFunctionTypeNode(node) || ts3.isFunctionDeclaration(node) || ts3.isArrowFunction(node)) {
+      const parameters = node.parameters.map(
+        (param) => {
+          let typeNode;
+          if (param.type) {
+            typeNode = this.convertTsTypeNode(param.type);
+          }
+          return {
+            name: param.name.getText(),
+            type: typeNode ?? AnyTypeNode,
+            optional: param.questionToken ? true : void 0,
+            default: param.initializer ? this.convertTsTypeNode(
+              param.initializer
+            ) : void 0
+          };
+        }
+      );
+      let returnType;
+      if (node.type !== void 0) {
+        returnType = this.convertTsTypeNode(node.type);
+      }
+      return {
+        type: "function",
+        parameters,
+        returnType,
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isIndexedAccessTypeNode(node)) {
+      if (ts3.isTypeReferenceNode(node.objectType) && ts3.isLiteralTypeNode(node.indexType)) {
+        const baseObject = this.convertTsTypeNode(node.objectType);
+        const accessor = node.indexType.literal.getText().replace(/["']/g, "");
+        if (!baseObject) {
+          this.context.throwError(
+            `Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`
+          );
+        } else if (baseObject.type === "object") {
+          if (Object.keys(baseObject.properties ?? {}).includes(accessor)) {
+            return baseObject.properties[accessor].node;
+          }
+          if (baseObject.additionalProperties) {
+            return baseObject.additionalProperties;
+          }
+        } else if (baseObject.type === "ref") {
+          return { ...baseObject, property: accessor };
+        } else {
+          this.context.throwError(
+            `Error: Index access on non object/ref type ${baseObject.type}`
+          );
+        }
+      }
+      let queryNode = node.objectType;
+      if (ts3.isParenthesizedTypeNode(node.objectType)) {
+        queryNode = node.objectType.type;
+      }
+      if (ts3.isTypeQueryNode(queryNode)) {
+        const elements = this.tsNodeToType(node.objectType);
+        return {
+          type: "or",
+          or: [...elements.elementTypes.map((element) => element.type)]
+        };
+      }
+      const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+      const syntheticType = this.context.typeChecker.typeToTypeNode(
+        effectiveType,
+        node,
+        ts3.NodeBuilderFlags.NoTruncation
+      );
+      if (syntheticType) {
+        return this.tsNodeToType(syntheticType);
+      }
+      this.context.throwError(
+        `Error: could not solve IndexedAccessType: ${node.getFullText()}`
+      );
+    }
+    if (ts3.isTypeQueryNode(node)) {
+      const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+      const syntheticType = this.context.typeChecker.typeToTypeNode(
+        effectiveType,
+        node,
+        ts3.NodeBuilderFlags.NoTruncation
+      );
+      if (syntheticType) {
+        return this.tsNodeToType(syntheticType);
+      }
+      this.context.throwError(
+        `Error: could not synthesize type for ${node.getText()}`
+      );
+    }
+    if (ts3.isTypeOperatorNode(node)) {
+      return this.tsNodeToType(node.type);
+    }
+    this.context.throwError(
+      `Unimplemented type ${ts3.SyntaxKind[node.kind]} at ${node.getText()}`
+    );
+  }
+  tsLiteralToType(node) {
+    if (ts3.isAsExpression(node)) {
+      return this.tsLiteralToType(node.expression);
+    }
+    if (ts3.isNumericLiteral(node)) {
+      return {
+        type: "number",
+        const: Number(node.text),
+        ...decorateNode(node)
+      };
+    }
+    if (ts3.isStringLiteral(node)) {
+      return {
+        type: "string",
+        const: node.text,
+        ...decorateNode(node)
+      };
+    }
+    if (node.kind === ts3.SyntaxKind.TrueKeyword) {
+      return {
+        type: "boolean",
+        const: true,
+        ...decorateNode(node)
+      };
+    }
+    if (node.kind === ts3.SyntaxKind.FalseKeyword) {
+      return {
+        type: "boolean",
+        const: false,
+        ...decorateNode(node)
+      };
+    }
+    if (node.kind === ts3.SyntaxKind.NullKeyword) {
+      return { type: "null", ...decorateNode(node) };
+    }
+    if (ts3.isPrefixUnaryExpression(node)) {
+      this.context.throwError("Prefix unary expressions not supported");
+    }
+    if (ts3.isArrayLiteralExpression(node)) {
+      const arrayElements = [];
+      node.elements.forEach((element) => {
+        if (ts3.isSpreadElement(element)) {
+          const arrayReference = this.resolveLiteralReference(
+            element.expression
+          );
+          arrayElements.push(...arrayReference.const ?? []);
+        } else {
+          arrayElements.push(this.tsLiteralToType(element));
+        }
+      });
+      return {
+        type: "array",
+        elementType: { type: "any" },
+        const: arrayElements
+      };
+    }
+    if (ts3.isObjectLiteralExpression(node)) {
+      const ret = {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      };
+      node.properties.forEach((property) => {
+        if (ts3.isPropertyAssignment(property) && property.name) {
+          const propertyName = getPropertyNameText(property.name);
+          ret.properties[propertyName] = {
+            required: true,
+            node: this.tsLiteralToType(property.initializer)
+          };
+        } else if (ts3.isSpreadAssignment(property)) {
+          const spreadValue = this.resolveLiteralReference(
+            property.expression
+          );
+          ret.properties = {
+            ...ret.properties,
+            ...spreadValue.properties
+          };
+        }
+      });
+      return ret;
+    }
+    if (ts3.isIdentifier(node)) {
+      return this.resolveLiteralReference(node);
+    }
+    this.context.throwError(
+      `Literal type not understood ${ts3.SyntaxKind[node.kind]} at ${node.getText()}`
+    );
+  }
+  resolveLiteralReference(expression) {
+    if (ts3.isIdentifier(expression)) {
+      const symbol = this.context.typeChecker.getSymbolAtLocation(expression);
+      let expressionReference = symbol?.declarations?.[0];
+      if (symbol && expressionReference && ts3.isImportSpecifier(expressionReference)) {
+        const referencedDeclaration = this.context.typeChecker.getAliasedSymbol(symbol);
+        expressionReference = referencedDeclaration.declarations?.[0];
+      }
+      if (expressionReference && ts3.isVariableDeclaration(expressionReference) && expressionReference.initializer) {
+        return this.convertVariable(
+          expressionReference.parent.parent
+        );
+      }
+      this.context.throwError(
+        `Error: Can't resolve non-variable declaration ${expressionReference?.getText()}`
+      );
+    }
+    this.context.throwError(
+      `Error: Can't resolve non-identifier reference in literal ${expression.getText()}`
+    );
+  }
+  resolveFunctionCall(functionCall, document) {
+    if (ts3.isArrowFunction(functionCall)) {
+      const declaredReturnType = functionCall.parent.type;
+      if (declaredReturnType) {
+        return this.tsNodeToType(declaredReturnType);
+      }
+    }
+    const functionReturnType = this.context.typeChecker.getTypeAtLocation(functionCall);
+    let syntheticNode = this.context.typeChecker.typeToTypeNode(
+      functionReturnType,
+      document,
+      void 0
+    );
+    if (ts3.isArrowFunction(functionCall)) {
+      const syntheticWithParameters = {
+        ...syntheticNode,
+        parameters: functionCall.parameters
+      };
+      syntheticNode = syntheticWithParameters;
+    }
+    if (syntheticNode) {
+      if (ts3.isTypeReferenceNode(syntheticNode) && ts3.isIdentifier(syntheticNode.typeName)) {
+        const { typeName } = syntheticNode;
+        if (this.context.customPrimitives.includes(typeName.text)) {
+          return this.makeBasicRefNode(syntheticNode);
+        }
+        const declarationSymbol = typeName.symbol;
+        if (declarationSymbol && declarationSymbol.declarations?.[0]) {
+          const declaration = declarationSymbol.declarations[0];
+          if (ts3.isTypeAliasDeclaration(declaration) || ts3.isInterfaceDeclaration(declaration)) {
+            return this.convertDeclaration(declaration);
+          }
+        }
+        this.context.throwError(
+          `Error: could not get referenced type ${syntheticNode.getText()}`
+        );
+      }
+      return this.tsNodeToType(syntheticNode);
+    }
+    this.context.throwError(
+      `Error: could not determine effective return type of ${functionCall.getText()}`
+    );
+  }
+  tsObjectMembersToProperties(node) {
+    const ret = {
+      properties: {},
+      additionalProperties: false
+    };
+    node.members.forEach((member) => {
+      if (ts3.isPropertySignature(member) && member.type) {
+        const name = getPropertyNameText(member.name);
+        ret.properties[name] = {
+          required: !isOptionalProperty(member),
+          node: {
+            ...this.convertTsTypeNode(member.type) ?? AnyTypeNode,
+            ...decorateNode(member)
+          }
+        };
+      } else if (ts3.isIndexSignatureDeclaration(member)) {
+        const param = member.parameters[0];
+        if (param.type?.kind !== ts3.SyntaxKind.StringKeyword) {
+          this.context.throwError(
+            "Will not convert non-string index signature"
+          );
+        }
+        ret.additionalProperties = this.convertTsTypeNode(member.type) ?? AnyTypeNode;
+      }
+    });
+    return ret;
+  }
+  tsTupleToType(node) {
+    if (node.elements.length === 0) {
+      return { elementTypes: [], additionalItems: false, minItems: 0 };
+    }
+    const hasRest = ts3.isRestTypeNode(node.elements[node.elements.length - 1]);
+    const [elements, rest] = hasRest ? [
+      node.elements.slice(0, node.elements.length - 1),
+      node.elements[node.elements.length - 1]
+    ] : [[...node.elements], void 0];
+    const elementTypes = elements.map((element) => {
+      if (ts3.isNamedTupleMember(element)) {
+        let typeNode;
+        if (element.type) {
+          typeNode = this.convertTsTypeNode(element.type);
+        }
+        return {
+          name: element.name.text,
+          type: typeNode ?? AnyTypeNode,
+          optional: element.questionToken ? true : void 0
+        };
+      }
+      return {
+        type: this.convertTsTypeNode(tsStripOptionalType(element)),
+        optional: ts3.isOptionalTypeNode(element)
+      };
+    });
+    const additionalItems = rest ? this.convertTsTypeNode(rest.type.elementType) ?? AnyTypeNode : false;
+    const firstOptional = elementTypes.findIndex(
+      (element) => element.optional === true
+    );
+    const minItems = firstOptional === -1 ? elements.length : firstOptional;
+    return {
+      elementTypes,
+      ...additionalItems && additionalItems.type === "any" ? { additionalItems: AnyTypeNode } : { additionalItems },
+      minItems
+    };
+  }
+  handleHeritageClauses(clauses, baseObject, typeChecker) {
+    let newProperties = {};
+    const additionalPropertiesCollector = [];
+    let extendsType;
+    clauses.forEach((heritageClause) => {
+      heritageClause.types.forEach((parent) => {
+        let typeToApply;
+        const typeName = parent.expression.getText();
+        if (isMappedTypeNode(typeName)) {
+          typeToApply = this.makeMappedType(typeName, parent);
+        } else {
+          const parentType = typeChecker.getTypeAtLocation(parent);
+          const parentSymbol = parentType.symbol;
+          const parentDeclarations = parentSymbol?.declarations;
+          if (!parentDeclarations?.[0]) {
+            this.context.throwError(
+              `Error: Unable to get underlying interface for extending class ${parent.getFullText()}`
+            );
+          }
+          let parentInterface;
+          if (ts3.isTypeLiteralNode(parentDeclarations?.[0]) && ts3.isTypeAliasDeclaration(parentDeclarations?.[0].parent)) {
+            parentInterface = parentDeclarations?.[0].parent;
+          } else {
+            parentInterface = parentDeclarations?.[0];
+          }
+          if (this.context.customPrimitives.includes(parentInterface.name.text)) {
+            extendsType = this.makeBasicRefNode(parent);
+            return;
+          }
+          typeToApply = this.convertDeclaration(parentInterface);
+          if (typeToApply.extends) {
+            extendsType = typeToApply.extends;
+          }
+          if (parentInterface.typeParameters && parent.typeArguments) {
+            typeToApply = this.resolveGenerics(
+              typeToApply,
+              parentInterface.typeParameters,
+              parent.typeArguments
+            );
+          } else if (isGenericNodeType(baseObject)) {
+            baseObject.genericTokens.push(
+              ...typeToApply.genericTokens ?? []
+            );
+          }
+        }
+        newProperties = {
+          ...newProperties,
+          ...typeToApply.properties
+        };
+        if (typeToApply.additionalProperties) {
+          additionalPropertiesCollector.push(typeToApply.additionalProperties);
+        }
+      });
+    });
+    let additionalProperties = false;
+    if (baseObject.additionalProperties) {
+      if (additionalPropertiesCollector.length === 0) {
+        additionalProperties = baseObject.additionalProperties;
+      } else {
+        additionalPropertiesCollector.push(baseObject.additionalProperties);
+        additionalProperties = additionalPropertiesCollector.length === 1 ? additionalPropertiesCollector[0] : {
+          type: "or",
+          or: additionalPropertiesCollector
+        };
+      }
+    } else if (additionalPropertiesCollector.length === 1) {
+      additionalProperties = additionalPropertiesCollector[0];
+    } else if (additionalPropertiesCollector.length >= 1) {
+      additionalProperties = {
+        type: "or",
+        or: additionalPropertiesCollector
+      };
+    }
+    return {
+      ...baseObject,
+      ...extendsType ? { extends: extendsType } : {},
+      properties: { ...newProperties, ...baseObject.properties },
+      additionalProperties
+    };
+  }
+  resolveGenerics(baseInterface, typeParameters, typeArguments) {
+    if (typeArguments && typeArguments.length === 0) return baseInterface;
+    const genericMap = /* @__PURE__ */ new Map();
+    typeParameters.forEach((tp, i) => {
+      let typeToProcess;
+      if (typeArguments && i < typeArguments.length) {
+        typeToProcess = typeArguments[i];
+      } else if (tp.default) {
+        typeToProcess = tp.default;
+      } else {
+        typeToProcess = ts3.factory.createKeywordTypeNode(
+          ts3.SyntaxKind.AnyKeyword
+        );
+      }
+      const processedNodeType = this.convertTsTypeNode(typeToProcess);
+      if (processedNodeType) {
+        genericMap.set(tp.name.getText(), processedNodeType);
+      }
+    });
+    return fillInGenerics(baseInterface, genericMap);
+  }
+  generateGenerics(params) {
+    const genericArray = [];
+    params?.forEach((param) => {
+      const serializedObject = {
+        symbol: param.name.text
+      };
+      if (param.constraint) {
+        serializedObject.constraints = this.convertTsTypeNode(param.constraint);
+      } else {
+        serializedObject.constraints = AnyTypeNode;
+      }
+      if (param.default) {
+        serializedObject.default = this.convertTsTypeNode(param.default);
+      } else {
+        serializedObject.default = AnyTypeNode;
+      }
+      genericArray.push(serializedObject);
+    });
+    return genericArray;
+  }
+  resolveRefNode(node) {
+    let refName;
+    let namespace;
+    if (node.typeName.kind === ts3.SyntaxKind.QualifiedName) {
+      namespace = node.typeName.left.getText();
+      refName = node.typeName.right.getText();
+    } else {
+      refName = node.typeName.text;
+    }
+    if (isTypeReferenceGeneric(node, this.context.typeChecker)) {
+      if (ts3.isIndexedAccessTypeNode(node.parent)) {
+        const genericSymbol = this.context.typeChecker.getSymbolAtLocation(
+          node.typeName
+        );
+        const typeParameters = this.generateGenerics(
+          genericSymbol?.declarations
+        );
+        const typeParameter = typeParameters[0];
+        if (typeParameter) {
+          if (typeParameter.constraints) {
+            return typeParameter.constraints;
+          }
+          if (typeParameter.default) {
+            return typeParameter.default;
+          }
+        }
+        return AnyTypeNode;
+      }
+      return { type: "ref", ref: node.getText(), ...decorateNode(node) };
+    }
+    if (refName === "Array") {
+      const typeArgs = node.typeArguments;
+      return {
+        type: "array",
+        elementType: typeArgs ? this.convertTsTypeNode(typeArgs[0]) ?? AnyTypeNode : AnyTypeNode,
+        ...decorateNode(node)
+      };
+    }
+    if (refName === "Record") {
+      const indexType = node.typeArguments?.[0];
+      const valueType = node.typeArguments?.[1];
+      return {
+        type: "record",
+        keyType: this.convertTsTypeNode(indexType) ?? AnyTypeNode,
+        valueType: this.convertTsTypeNode(valueType) ?? AnyTypeNode,
+        ...decorateNode(node)
+      };
+    }
+    if (isMappedTypeNode(refName)) {
+      return this.makeMappedType(refName, node);
+    }
+    if (isTypeScriptLibType(node, this.context.typeChecker)) {
+      return this.makeBasicRefNode(node);
+    }
+    if (!this.context.customPrimitives.includes(refName)) {
+      const typeInfo = getReferencedType(node, this.context.typeChecker);
+      if (typeInfo) {
+        const convertedType = this.convertTopLevelNode(typeInfo.declaration);
+        const genericParams = typeInfo.declaration.typeParameters;
+        const genericArgs = node.typeArguments;
+        if (convertedType && genericParams && genericArgs) {
+          const resolvedType = this.resolveGenerics(
+            convertedType,
+            genericParams,
+            genericArgs
+          );
+          if ("name" in resolvedType && genericArgs.length > 0) {
+            const argsText = Array.from(genericArgs).map((arg) => arg.getText()).join(", ");
+            const baseName = namespace ? `${namespace}.${refName}` : refName;
+            return { ...resolvedType, name: `${baseName}<${argsText}>` };
+          }
+          if (namespace && "name" in resolvedType) {
+            return { ...resolvedType, name: `${namespace}.${refName}` };
+          }
+          return resolvedType;
+        }
+        if (convertedType) {
+          if (namespace && "name" in convertedType) {
+            return { ...convertedType, name: `${namespace}.${refName}` };
+          }
+          return convertedType;
+        }
+      }
+      this.context.throwError(
+        `Can't find referenced type ${refName}, is it available in the current package or node_modules?`
+      );
+    }
+    return this.makeBasicRefNode(node);
+  }
+  makeMappedType(refName, node) {
+    if (refName === "Pick" || refName === "Omit" || refName === "Exclude") {
+      const baseType = node.typeArguments?.[0];
+      const modifiers = node.typeArguments?.[1];
+      const baseObj = this.convertTsTypeNode(baseType);
+      if (refName === "Exclude") {
+        if (baseObj.type === "or") {
+          return applyExcludeToNodeType(
+            baseObj,
+            this.convertTsTypeNode(modifiers)
+          );
+        }
+        throw new ConversionError(
+          "Error: Can't solve Exclude type on non-union node"
+        );
+      } else {
+        return applyPickOrOmitToNodeType(
+          baseObj,
+          refName,
+          getStringLiteralsFromUnion(modifiers)
+        );
+      }
+    }
+    if (refName === "Partial" || refName === "Required") {
+      const baseType = node.typeArguments?.[0];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifier = refName !== "Partial";
+      return applyPartialOrRequiredToNodeType(baseObj, modifier);
+    }
+    this.context.throwError(`Can't convert non-MappedType ${refName}`);
+  }
+  makeBasicRefNode(node) {
+    const genericArgs = [];
+    if (node.typeArguments) {
+      node.typeArguments.forEach((typeArg) => {
+        let convertedNode;
+        if (isTopLevelDeclaration(typeArg)) {
+          convertedNode = this.convertDeclaration(typeArg);
+        } else {
+          convertedNode = this.convertTsTypeNode(typeArg);
+        }
+        if (convertedNode) {
+          genericArgs.push(convertedNode);
+        } else {
+          this.context.throwError(
+            `Conversion Error: Couldn't convert type argument in type ${node.getText()}`
+          );
+        }
+      });
+    }
+    let ref;
+    if (ts3.isTypeReferenceNode(node)) {
+      if (node.typeName.kind === ts3.SyntaxKind.QualifiedName) {
+        ref = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
+      } else if (node.pos === -1 && ts3.isIdentifier(node.typeName)) {
+        ref = node.typeName.text;
+      } else {
+        ref = node.getText();
+      }
+    } else {
+      ref = node.getText();
+    }
+    return {
+      type: "ref",
+      ref,
+      ...decorateNode(node),
+      genericArguments: genericArgs.length > 0 ? genericArgs : void 0
+    };
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/xlr-to-ts.ts
+import { isGenericNamedType, isPrimitiveTypeNode as isPrimitiveTypeNode2 } from "@xlr-lib/xlr-utils";
+import ts4 from "typescript";
+var templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+var tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
+var TSWriter = class {
+  context;
+  importSet;
+  additionalTypes;
+  constructor(factory) {
+    this.context = {
+      factory: factory ?? ts4.factory,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      }
+    };
+    this.importSet = /* @__PURE__ */ new Set();
+    this.additionalTypes = /* @__PURE__ */ new Map();
+  }
+  convertNamedType(type) {
+    this.importSet.clear();
+    this.additionalTypes.clear();
+    const finalNode = this.convertNamedTypeNode(type);
+    const referencedTypes = this.importSet.size > 0 ? this.importSet : void 0;
+    const additionalTypes = this.additionalTypes.size > 0 ? this.additionalTypes : void 0;
+    return {
+      type: this.makeAnnotations(finalNode, type),
+      referencedTypes,
+      additionalTypes
+    };
+  }
+  convertNamedTypeNode(type) {
+    const typeName = type.name;
+    const tsNode = this.convertTypeNode(type);
+    let customPrimitiveHeritageClass;
+    if (type.type === "object" && type.extends) {
+      const refName = type.extends.ref.split("<")[0];
+      customPrimitiveHeritageClass = [
+        this.context.factory.createHeritageClause(
+          ts4.SyntaxKind.ExtendsKeyword,
+          [
+            this.context.factory.createExpressionWithTypeArguments(
+              this.context.factory.createIdentifier(refName),
+              type.extends.genericArguments ? type.extends.genericArguments.map(
+                (node) => this.convertTypeNode(node)
+              ) : void 0
+            )
+          ]
+        )
+      ];
+    }
+    let generics;
+    if (isGenericNamedType(type)) {
+      generics = this.createTypeParameters(type);
+      type.genericTokens.forEach((token) => {
+        if (this.importSet.has(token.symbol)) {
+          this.importSet.delete(token.symbol);
+        }
+      });
+    }
+    let finalNode;
+    if (ts4.isTypeLiteralNode(tsNode)) {
+      finalNode = this.makeInterfaceDeclaration(
+        typeName,
+        tsNode.members,
+        generics,
+        customPrimitiveHeritageClass
+      );
+    } else {
+      finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);
+    }
+    return finalNode;
+  }
+  convertTypeNode(type) {
+    if (type.type === "object") {
+      return this.createObjectNode(type);
+    }
+    if (type.type === "and") {
+      return this.context.factory.createIntersectionTypeNode(
+        type.and.map((element) => {
+          return this.convertTypeNode(element);
+        })
+      );
+    }
+    if (type.type === "or") {
+      return this.context.factory.createUnionTypeNode(
+        type.or.map((element) => {
+          return this.convertTypeNode(element);
+        })
+      );
+    }
+    if (type.type === "array") {
+      if (type.const) {
+        return this.context.factory.createTupleTypeNode(
+          type.const.map(
+            (element) => this.convertTypeNode(element)
+          )
+        );
+      }
+      return this.context.factory.createTypeReferenceNode(
+        this.context.factory.createIdentifier("Array"),
+        [this.convertTypeNode(type.elementType)]
+      );
+    }
+    if (isPrimitiveTypeNode2(type)) {
+      return this.createPrimitiveNode(type);
+    }
+    if (type.type === "conditional") {
+      return this.createConditionalTypeNode(type);
+    }
+    if (type.type === "function") {
+      return this.createFunctionDeclarationNode(type);
+    }
+    if (type.type === "record") {
+      return this.createRecordNode(type);
+    }
+    if (type.type === "ref") {
+      return this.createRefNode(type);
+    }
+    if (type.type === "template") {
+      return this.createTemplateLiteral(type);
+    }
+    if (type.type === "tuple") {
+      return this.createTupleNode(type);
+    }
+    this.context.throwError(
+      `Unable to convert node type: ${type.type}`
+    );
+  }
+  createRefNode(xlrNode) {
+    const typeArgs = [];
+    if (xlrNode.genericArguments) {
+      xlrNode.genericArguments.forEach((genericArg) => {
+        if (genericArg.name) {
+          const additionalType = this.convertNamedTypeNode(
+            genericArg
+          );
+          this.additionalTypes.set(genericArg.name, additionalType);
+        } else if (genericArg.type === "and") {
+          genericArg.and.forEach((type) => {
+            if (type.name) {
+              const additionalType = this.convertNamedTypeNode(
+                type
+              );
+              this.additionalTypes.set(type.name, additionalType);
+            }
+          });
+        } else if (genericArg.type === "or") {
+          genericArg.or.forEach((type) => {
+            if (type.name) {
+              const additionalType = this.convertNamedTypeNode(
+                type
+              );
+              this.additionalTypes.set(type.name, additionalType);
+            }
+          });
+        } else {
+          typeArgs.push(this.convertTypeNode(genericArg));
+        }
+      });
+    }
+    const importName = xlrNode.ref.split("<")[0];
+    this.importSet.add(importName);
+    return this.context.factory.createTypeReferenceNode(importName, typeArgs);
+  }
+  createPrimitiveNode(xlrNode) {
+    if ((xlrNode.type === "string" || xlrNode.type === "boolean" || xlrNode.type === "number") && xlrNode.const || xlrNode.type === "null") {
+      return this.context.factory.createLiteralTypeNode(
+        this.createLiteralTypeNode(xlrNode)
+      );
+    }
+    switch (xlrNode.type) {
+      case "string":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.StringKeyword
+        );
+      case "number":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.NumberKeyword
+        );
+      case "boolean":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.BooleanKeyword
+        );
+      case "any":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.AnyKeyword
+        );
+      case "unknown":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.UnknownKeyword
+        );
+      case "never":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.NeverKeyword
+        );
+      case "undefined":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.UndefinedKeyword
+        );
+      case "void":
+        return this.context.factory.createKeywordTypeNode(
+          ts4.SyntaxKind.VoidKeyword
+        );
+      default:
+        this.context.throwError(
+          `Unknown primitive type ${xlrNode.type}`
+        );
+    }
+  }
+  createLiteralTypeNode(xlrNode) {
+    if (xlrNode.type === "boolean") {
+      return xlrNode.const ? this.context.factory.createTrue() : this.context.factory.createFalse();
+    }
+    if (xlrNode.type === "number") {
+      return xlrNode.const ? this.context.factory.createNumericLiteral(xlrNode.const) : this.context.throwError(
+        "Can't make literal type out of non constant number"
+      );
+    }
+    if (xlrNode.type === "string") {
+      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const, true) : this.context.throwError(
+        "Can't make literal type out of non constant string"
+      );
+    }
+    if (xlrNode.type === "null") {
+      return this.context.factory.createNull();
+    }
+    this.context.throwError(`Can't make literal out of type ${xlrNode.type}`);
+  }
+  createTupleNode(xlrNode) {
+    return this.context.factory.createTupleTypeNode(
+      xlrNode.elementTypes.map((e) => {
+        if (e.name) {
+          return this.context.factory.createNamedTupleMember(
+            void 0,
+            this.context.factory.createIdentifier(e.name),
+            e.optional ? this.context.factory.createToken(ts4.SyntaxKind.QuestionToken) : void 0,
+            this.convertTypeNode(e.type)
+          );
+        }
+        return this.convertTypeNode(e.type);
+      })
+    );
+  }
+  createFunctionDeclarationNode(xlrNode) {
+    return this.context.factory.createFunctionTypeNode(
+      void 0,
+      xlrNode.parameters.map((e) => {
+        return this.context.factory.createParameterDeclaration(
+          void 0,
+          void 0,
+          e.name,
+          e.optional ? this.context.factory.createToken(ts4.SyntaxKind.QuestionToken) : void 0,
+          this.convertTypeNode(e.type),
+          e.default ? this.createLiteralTypeNode(e.default) : void 0
+        );
+      }),
+      xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(ts4.SyntaxKind.VoidKeyword)
+    );
+  }
+  createRecordNode(xlrNode) {
+    const keyType = this.convertTypeNode(xlrNode.keyType);
+    const valueType = this.convertTypeNode(xlrNode.valueType);
+    return this.context.factory.createTypeReferenceNode(
+      this.context.factory.createIdentifier("Record"),
+      [keyType, valueType]
+    );
+  }
+  createConditionalTypeNode(xlrNode) {
+    const leftCheck = this.convertTypeNode(xlrNode.check.left);
+    const rightCheck = this.convertTypeNode(xlrNode.check.right);
+    const trueValue = this.convertTypeNode(xlrNode.value.true);
+    const falseValue = this.convertTypeNode(xlrNode.value.false);
+    return this.context.factory.createConditionalTypeNode(
+      leftCheck,
+      rightCheck,
+      trueValue,
+      falseValue
+    );
+  }
+  createObjectNode(xlrNode) {
+    const { properties, additionalProperties = false } = xlrNode;
+    const propertyNodes = [
+      ...Object.keys(properties).map((name) => ({ name, ...properties[name] })).map(
+        ({ name, node, required }) => this.makeAnnotations(
+          this.context.factory.createPropertySignature(
+            void 0,
+            // modifiers
+            name,
+            required ? void 0 : this.context.factory.createToken(ts4.SyntaxKind.QuestionToken),
+            this.convertTypeNode(node)
+          ),
+          node
+        )
+      )
+    ];
+    if (additionalProperties) {
+      propertyNodes.push(
+        this.context.factory.createIndexSignature(
+          void 0,
+          // modifiers
+          [
+            this.context.factory.createParameterDeclaration(
+              void 0,
+              // modifiers
+              void 0,
+              // dotdotdot token
+              "key",
+              void 0,
+              // question token
+              this.context.factory.createKeywordTypeNode(
+                ts4.SyntaxKind.StringKeyword
+              )
+            )
+          ],
+          this.convertTypeNode(additionalProperties)
+        )
+      );
+    }
+    return this.context.factory.createTypeLiteralNode(propertyNodes);
+  }
+  createTemplateLiteral(xlrNode) {
+    const templateSegments = xlrNode.format.split(templateTokenize);
+    let templateHead;
+    if (templateSegments.length % 2 === 0) {
+      templateHead = this.context.factory.createTemplateHead(
+        templateSegments[0]
+      );
+      templateSegments.splice(0, 1);
+    } else {
+      templateHead = this.context.factory.createTemplateHead("");
+    }
+    return this.context.factory.createTemplateLiteralType(
+      templateHead,
+      templateSegments.map((segments, i) => {
+        const [regexSegment, stringSegment = ""] = segments.split(tokenSplit);
+        let regexTemplateType;
+        if (regexSegment === ".*") {
+          regexTemplateType = ts4.SyntaxKind.StringKeyword;
+        } else if (regexSegment === "[0-9]*") {
+          regexTemplateType = ts4.SyntaxKind.NumberKeyword;
+        } else if (regexSegment === "true|false") {
+          regexTemplateType = ts4.SyntaxKind.BooleanKeyword;
+        } else {
+          this.context.throwError(
+            `Can't make template literal type from regex ${regexSegment}`
+          );
+        }
+        let stringTemplateType;
+        if (i === templateSegments.length - 1) {
+          stringTemplateType = this.context.factory.createTemplateTail(stringSegment);
+        } else {
+          stringTemplateType = this.context.factory.createTemplateMiddle(stringSegment);
+        }
+        return this.context.factory.createTemplateLiteralTypeSpan(
+          this.context.factory.createKeywordTypeNode(regexTemplateType),
+          stringTemplateType
+        );
+      })
+    );
+  }
+  createGenericArgumentNode(node) {
+    if (node) {
+      if (node.type === "object" && node.name) {
+        const additionalType = this.convertNamedTypeNode(
+          node
+        );
+        this.additionalTypes.set(node.name, additionalType);
+        return this.context.factory.createTypeReferenceNode(node.name);
+      }
+      return this.convertTypeNode(node);
+    }
+    return void 0;
+  }
+  makeAnnotations(tsNode, xlrAnnotations) {
+    let comment = xlrAnnotations.description;
+    if (!comment) {
+      return tsNode;
+    }
+    if (comment.includes("\n")) {
+      comment = `*
+${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
+`;
+    } else {
+      comment = `* ${comment} `;
+    }
+    return ts4.addSyntheticLeadingComment(
+      tsNode,
+      ts4.SyntaxKind.MultiLineCommentTrivia,
+      comment,
+      true
+    );
+  }
+  createTypeParameters(genericXLRNode) {
+    return genericXLRNode.genericTokens.map((generic) => {
+      return this.context.factory.createTypeParameterDeclaration(
+        void 0,
+        generic.symbol,
+        this.createGenericArgumentNode(generic.constraints),
+        this.createGenericArgumentNode(generic.default)
+      );
+    });
+  }
+  makeInterfaceDeclaration(name, node, generics, heritageClass) {
+    return this.context.factory.createInterfaceDeclaration(
+      this.context.factory.createModifiersFromModifierFlags(
+        ts4.ModifierFlags.Export
+      ),
+      this.context.factory.createIdentifier(name),
+      generics,
+      // type parameters
+      heritageClass,
+      // heritage
+      node
+    );
+  }
+  makeTypeDeclaration(name, node, generics) {
+    return this.context.factory.createTypeAliasDeclaration(
+      this.context.factory.createModifiersFromModifierFlags(
+        ts4.ModifierFlags.Export
+      ),
+      this.context.factory.createIdentifier(name),
+      generics,
+      // type parameters
+      node
+    );
+  }
+};
+function exportTypesToTypeScript(typesToExport, importMap) {
+  const writer = new TSWriter();
+  const referencedImports = /* @__PURE__ */ new Set();
+  const exportedTypes = /* @__PURE__ */ new Map();
+  const printer = ts4.createPrinter({ newLine: ts4.NewLineKind.LineFeed });
+  let resultFile = ts4.createSourceFile(
+    "output.d.ts",
+    "",
+    ts4.ScriptTarget.ES2017,
+    false,
+    ts4.ScriptKind.TS
+  );
+  typesToExport.forEach((typeNode) => {
+    const { type, referencedTypes, additionalTypes } = writer.convertNamedType(typeNode);
+    exportedTypes.set(typeNode.name, type);
+    additionalTypes?.forEach(
+      (additionalType, name) => exportedTypes.set(name, additionalType)
+    );
+    referencedTypes?.forEach(
+      (referencedType) => referencedImports.add(referencedType)
+    );
+  });
+  const typesToPrint = [];
+  exportedTypes.forEach(
+    (type) => typesToPrint.push(
+      printer.printNode(ts4.EmitHint.Unspecified, type, resultFile)
+    )
+  );
+  importMap.forEach((imports, packageName) => {
+    const applicableImports = imports.filter((i) => referencedImports.has(i));
+    if (applicableImports.length === 0) return;
+    resultFile = ts4.factory.updateSourceFile(resultFile, [
+      ts4.factory.createImportDeclaration(
+        /* modifiers */
+        void 0,
+        ts4.factory.createImportClause(
+          false,
+          void 0,
+          ts4.factory.createNamedImports(
+            applicableImports.map(
+              (i) => ts4.factory.createImportSpecifier(
+                false,
+                void 0,
+                ts4.factory.createIdentifier(i)
+              )
+            )
+          )
+        ),
+        ts4.factory.createStringLiteral(packageName)
+      ),
+      ...resultFile.statements
+    ]);
+  });
+  const headerText = printer.printFile(resultFile);
+  const nodeText = typesToPrint.join("\n");
+  return `${headerText}
+${nodeText}`;
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
+import ts5 from "typescript";
+import path2 from "path";
+import fs2 from "fs";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/writeManifest.ts
+import path from "path";
+import fs from "fs";
+function replacer(key, value) {
+  if (value instanceof Map) {
+    return Object.fromEntries(value.entries());
+  }
+  return value;
+}
+function writeManifest(capabilities, outputDirectory) {
+  const jsonManifest = JSON.stringify(capabilities, replacer, 4);
+  fs.writeFileSync(path.join(outputDirectory, "manifest.json"), jsonManifest);
+  const tsManifestFile = `${[...capabilities.capabilities?.values() ?? []].flat(2).map((capability) => {
+    return `const ${capability} = require("./${capability}.json")`;
+  }).join("\n")}
+
+    module.exports = {
+      "pluginName": "${capabilities.pluginName}",
+      "capabilities": {
+        ${[...capabilities.capabilities?.entries() ?? []].map(([capabilityName, provides]) => {
+    return `"${capabilityName}":[${provides.join(",")}],`;
+  }).join("\n		")}
+      },
+      "customPrimitives": [
+        ${[capabilities.customPrimitives?.map((i) => `"${i}"`).join(",") ?? ""]}
+      ]
+    }
+`;
+  fs.writeFileSync(path.join(outputDirectory, "manifest.js"), tsManifestFile);
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
+function converter(sourceFile, outputDirectory, customPrimitives, tsOptions = {}) {
+  const program = ts5.createProgram([sourceFile], tsOptions);
+  fs2.mkdirSync(outputDirectory, { recursive: true });
+  const checker = program.getTypeChecker();
+  const converter2 = new TsConverter(checker, customPrimitives);
+  const convertedTypes = converter2.convertSourceFile(
+    program.getSourceFiles()[0]
+  );
+  if (convertedTypes.data.types.length === 0) {
+    return void 0;
+  }
+  convertedTypes.data.types.forEach((type) => {
+    fs2.writeFileSync(
+      path2.join(outputDirectory, `${type.name}.json`),
+      JSON.stringify(type, void 0, 4)
+    );
+  });
+  const manifest = {
+    pluginName: "Types",
+    capabilities: /* @__PURE__ */ new Map([["Types", convertedTypes.convertedTypes]]),
+    customPrimitives
+  };
+  writeManifest(manifest, outputDirectory);
+}
+export {
+  ConversionError,
+  TSWriter,
+  TsConverter,
+  converter,
+  exportTypesToTypeScript,
+  writeManifest
+};
+//# sourceMappingURL=index.mjs.map