@wener/utils 1.1.27 → 1.1.29

package/lib/schema/typebox/gen/codegen/typescript/typescript-to-typebox.js

@@ -1,620 +1,596 @@
 import * as ts from 'typescript';
-import { JsDoc } from '../common/jsdoc.js';
-
-class TypeScriptToTypeBoxError extends Error {
-  constructor(diagnostics) {
-    super("");
-    this.diagnostics = diagnostics;
-  }
+import { JsDoc } from '../common/jsdoc';
+export class TypeScriptToTypeBoxError extends Error {
+    diagnostics;
+    constructor(diagnostics){
+        super('');
+        this.diagnostics = diagnostics;
+    }
 }
-var TypeScriptToTypeBox;
-((TypeScriptToTypeBox2) => {
-  const transpilerOptions = {
-    compilerOptions: {
-      strict: true,
-      target: ts.ScriptTarget.ES2022
-    }
-  };
-  const typenames = /* @__PURE__ */ new Set();
-  let recursiveDeclaration = null;
-  let blockLevel = 0;
-  let useImports = false;
-  let useOptions = false;
-  let useGenerics = false;
-  let useCloneType = false;
-  let useExportsEverything = false;
-  let useIdentifiers = false;
-  let useTypeBoxImport = true;
-  function FindRecursiveParent(decl, node) {
-    return ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText() || node.getChildren().some((node2) => FindRecursiveParent(decl, node2));
-  }
-  function FindRecursiveThis(node) {
-    return node.getChildren().some((node2) => ts.isThisTypeNode(node2) || FindRecursiveThis(node2));
-  }
-  function FindTypeName(node, name) {
-    const found = typenames.has(name) || node.getChildren().some((node2) => {
-      return (ts.isInterfaceDeclaration(node2) || ts.isTypeAliasDeclaration(node2)) && node2.name.getText() === name || FindTypeName(node2, name);
-    });
-    if (found)
-      typenames.add(name);
-    return found;
-  }
-  function IsRecursiveType(decl) {
-    const check1 = ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node));
-    const check2 = ts.isInterfaceDeclaration(decl) && FindRecursiveThis(decl);
-    return check1 || check2;
-  }
-  function IsReadonlyProperty(node) {
-    return node.modifiers !== void 0 && node.modifiers.find((modifier) => modifier.getText() === "readonly") !== void 0;
-  }
-  function IsOptionalProperty(node) {
-    return node.questionToken !== void 0;
-  }
-  function IsExport(node) {
-    return blockLevel === 0 && (useExportsEverything || node.modifiers !== void 0 && node.modifiers.find((modifier) => modifier.getText() === "export") !== void 0);
-  }
-  function IsNamespace(node) {
-    return node.flags === ts.NodeFlags.Namespace;
-  }
-  function ResolveJsDocComment(node) {
-    const content = node.getFullText().trim();
-    if (node.kind === ts.SyntaxKind.LiteralType) {
-      if (content.startsWith("/**")) {
-        return content.slice(0, content.lastIndexOf("*/") + 2).replace(/\*+\/$/, "\n$0");
-      } else {
-        return "";
-      }
-    }
-    const indices = [content.indexOf("/**"), content.indexOf("type"), content.indexOf("interface")].map(
-      (n) => n === -1 ? Infinity : n
-    );
-    if (indices[0] === -1 || indices[1] < indices[0] || indices[2] < indices[0])
-      return "";
-    for (let i = indices[0]; i < content.length; i++) {
-      if (content[i] === "*" && content[i + 1] === "/")
-        return content.slice(0, i + 2);
-    }
-    return "";
-  }
-  function ResolveOptions(node) {
-    const content = ResolveJsDocComment(node);
-    return JsDoc.Parse(content);
-  }
-  function ResolveIdentifier(node) {
-    function* resolve(node2) {
-      if (node2.parent)
-        yield* resolve(node2.parent);
-      if (ts.isModuleDeclaration(node2))
-        yield node2.name.getText();
-    }
-    return [...resolve(node), node.name.getText()].join(".");
-  }
-  function UnwrapModifier(type) {
-    for (let i = 0; i < type.length; i++)
-      if (type[i] === "(")
-        return type.slice(i + 1, type.length - 1);
-    return type;
-  }
-  function InjectOptions(type, options) {
-    if (globalThis.Object.keys(options).length === 0)
-      return type;
-    if (type.indexOf("Type.ReadonlyOptional") === 0)
-      return `Type.ReadonlyOptional( ${InjectOptions(UnwrapModifier(type), options)} )`;
-    if (type.indexOf("Type.Readonly") === 0)
-      return `Type.Readonly( ${InjectOptions(UnwrapModifier(type), options)} )`;
-    if (type.indexOf("Type.Optional") === 0)
-      return `Type.Optional( ${InjectOptions(UnwrapModifier(type), options)} )`;
-    const encoded = JSON.stringify(options);
-    if (type.lastIndexOf("]") === type.length - 1)
-      useCloneType = true;
-    if (type.lastIndexOf("]") === type.length - 1)
-      return `CloneType(${type}, ${encoded})`;
-    if (type.indexOf("(") === -1) {
-      useCloneType = true;
-      return `CloneType(${type}, ${encoded})`;
-    }
-    if (type.lastIndexOf("()") === type.length - 2)
-      return type.slice(0, type.length - 1) + `${encoded})`;
-    if (type.lastIndexOf("})") === type.length - 2)
-      return type.slice(0, type.length - 1) + `, ${encoded})`;
-    if (type.lastIndexOf("])") === type.length - 2)
-      return type.slice(0, type.length - 1) + `, ${encoded})`;
-    if (type.lastIndexOf(")") === type.length - 1)
-      return type.slice(0, type.length - 1) + `, ${encoded})`;
-    return type;
-  }
-  function* SourceFile(node) {
-    for (const next of node.getChildren()) {
-      yield* Visit(next);
-    }
-  }
-  function* PropertySignature(node) {
-    const [readonly, optional] = [IsReadonlyProperty(node), IsOptionalProperty(node)];
-    const options = ResolveOptions(node);
-    const type_0 = Collect(node.type);
-    const type_1 = InjectOptions(type_0, options);
-    if (readonly && optional) {
-      return yield `${node.name.getText()}: Type.ReadonlyOptional(${type_1})`;
-    } else if (readonly) {
-      return yield `${node.name.getText()}: Type.Readonly(${type_1})`;
-    } else if (optional) {
-      return yield `${node.name.getText()}: Type.Optional(${type_1})`;
-    } else {
-      return yield `${node.name.getText()}: ${type_1}`;
-    }
-  }
-  function* ArrayTypeNode(node) {
-    const type = Collect(node.elementType);
-    yield `Type.Array(${type})`;
-  }
-  function* Block(node) {
-    blockLevel += 1;
-    const statments = node.statements.map((statement) => Collect(statement)).join("\n\n");
-    blockLevel -= 1;
-    yield `{
-${statments}
-}`;
-  }
-  function* TupleTypeNode(node) {
-    const types = node.elements.map((type) => Collect(type)).join(",\n");
-    yield `Type.Tuple([
-${types}
-])`;
-  }
-  function* UnionTypeNode(node) {
-    const types = node.types.map((type) => Collect(type)).join(",\n");
-    yield `Type.Union([
-${types}
-])`;
-  }
-  function* MappedTypeNode(node) {
-    const K = Collect(node.typeParameter);
-    const T = Collect(node.type);
-    const C = Collect(node.typeParameter.constraint);
-    const readonly = node.readonlyToken !== void 0;
-    const optional = node.questionToken !== void 0;
-    const readonly_subtractive = readonly && ts.isMinusToken(node.readonlyToken);
-    const optional_subtractive = optional && ts.isMinusToken(node.questionToken);
-    return yield readonly && optional ? readonly_subtractive && optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false), false))` : readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}), false))` : optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false)))` : `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T})))` : readonly ? readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Readonly(${T}))` : optional ? optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Optional(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Optional(${T}))` : `Type.Mapped(${C}, ${K} => ${T})`;
-  }
-  function* MethodSignature(node) {
-    const parameters = node.parameters.map(
-      (parameter) => parameter.dotDotDotToken !== void 0 ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)
-    ).join(", ");
-    const returnType = node.type === void 0 ? `Type.Unknown()` : Collect(node.type);
-    yield `${node.name.getText()}: Type.Function([${parameters}], ${returnType})`;
-  }
-  function* TemplateLiteralTypeNode(node) {
-    const collect = node.getChildren().map((node2) => Collect(node2)).join("");
-    yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])`;
-  }
-  function* TemplateLiteralTypeSpan(node) {
-    const collect = node.getChildren().map((node2) => Collect(node2)).join(", ");
-    if (collect.length > 0)
-      yield `${collect}`;
-  }
-  function* TemplateHead(node) {
-    if (node.text.length > 0)
-      yield `Type.Literal('${node.text}'), `;
-  }
-  function* TemplateMiddle(node) {
-    if (node.text.length > 0)
-      yield `Type.Literal('${node.text}'), `;
-  }
-  function* TemplateTail(node) {
-    if (node.text.length > 0)
-      yield `Type.Literal('${node.text}'), `;
-  }
-  function* ThisTypeNode(node) {
-    yield `This`;
-  }
-  function* IntersectionTypeNode(node) {
-    const types = node.types.map((type) => Collect(type)).join(",\n");
-    yield `Type.Intersect([
-${types}
-])`;
-  }
-  function* TypeOperatorNode(node) {
-    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
-      const type = Collect(node.type);
-      yield `Type.KeyOf(${type})`;
-    }
-    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
-      yield `Type.Readonly(${Collect(node.type)})`;
-    }
-  }
-  function* Parameter(node) {
-    yield Collect(node.type);
-  }
-  function* FunctionTypeNode(node) {
-    const parameters = node.parameters.map(
-      (parameter) => parameter.dotDotDotToken !== void 0 ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)
-    ).join(", ");
-    const returns = Collect(node.type);
-    yield `Type.Function([${parameters}], ${returns})`;
-  }
-  function* ConstructorTypeNode(node) {
-    const parameters = node.parameters.map((param) => Collect(param)).join(", ");
-    const returns = Collect(node.type);
-    yield `Type.Constructor([${parameters}], ${returns})`;
-  }
-  function* EnumDeclaration(node) {
-    useImports = true;
-    const exports = IsExport(node) ? "export " : "";
-    const members = node.members.map((member) => member.getText()).join(", ");
-    const enumType = `${exports}enum Enum${node.name.getText()} { ${members} }`;
-    const staticType = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
-    const type = `${exports}const ${node.name.getText()} = Type.Enum(Enum${node.name.getText()})`;
-    yield [enumType, "", staticType, type].join("\n");
-  }
-  function PropertiesFromTypeElementArray(members) {
-    const properties = members.filter((member) => !ts.isIndexSignatureDeclaration(member));
-    const indexers = members.filter((member) => ts.isIndexSignatureDeclaration(member));
-    const propertyCollect = properties.map((property) => Collect(property)).join(",\n");
-    const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : "";
-    if (properties.length === 0 && indexer.length > 0) {
-      return `{},
-{
-additionalProperties: ${indexer}
- }`;
-    } else if (properties.length > 0 && indexer.length > 0) {
-      return `{
-${propertyCollect}
-},
-{
-additionalProperties: ${indexer}
- }`;
-    } else {
-      return `{
-${propertyCollect}
-}`;
-    }
-  }
-  function* TypeLiteralNode(node) {
-    const members = PropertiesFromTypeElementArray(node.members);
-    yield* `Type.Object(${members})`;
-  }
-  function* InterfaceDeclaration(node) {
-    useImports = true;
-    const isRecursiveType = IsRecursiveType(node);
-    if (isRecursiveType)
-      recursiveDeclaration = node;
-    const heritage = node.heritageClauses !== void 0 ? node.heritageClauses.flatMap((node2) => Collect(node2)) : [];
-    if (node.typeParameters) {
-      useGenerics = true;
-      const exports = IsExport(node) ? "export " : "";
-      const identifier = ResolveIdentifier(node);
-      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };
-      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(", ");
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(", ");
-      const members = PropertiesFromTypeElementArray(node.members);
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
-      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(", ")}, ${rawTypeExpression}])`;
-      const type = InjectOptions(typeExpression, options);
-      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`;
-      yield `${typeDeclaration}`;
-    } else {
-      const exports = IsExport(node) ? "export " : "";
-      const identifier = ResolveIdentifier(node);
-      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };
-      const members = PropertiesFromTypeElementArray(node.members);
-      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
-      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(", ")}, ${rawTypeExpression}])`;
-      const type = InjectOptions(typeExpression, options);
-      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`;
-      yield `${staticDeclaration}
-${typeDeclaration}`;
-    }
-    recursiveDeclaration = null;
-  }
-  function* TypeAliasDeclaration(node) {
-    useImports = true;
-    const isRecursiveType = IsRecursiveType(node);
-    if (isRecursiveType)
-      recursiveDeclaration = node;
-    if (node.typeParameters) {
-      useGenerics = true;
-      const exports = IsExport(node) ? "export " : "";
-      const options = useIdentifiers ? { $id: ResolveIdentifier(node) } : {};
-      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(", ");
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(", ");
-      const type_0 = Collect(node.type);
-      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
-      const type_2 = InjectOptions(type_1, options);
-      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type_2}`;
-      yield `${typeDeclaration}`;
-    } else {
-      const exports = IsExport(node) ? "export " : "";
-      const options = useIdentifiers ? { $id: ResolveIdentifier(node), ...ResolveOptions(node) } : { ...ResolveOptions(node) };
-      const type_0 = Collect(node.type);
-      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
-      const type_2 = InjectOptions(type_1, options);
-      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
-      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type_2}`;
-      yield `${staticDeclaration}
-${typeDeclaration}`;
-    }
-    recursiveDeclaration = null;
-  }
-  function* HeritageClause(node) {
-    const types = node.types.map((node2) => Collect(node2));
-    if (types.length === 1)
-      return yield types[0];
-    yield types.join(", ");
-  }
-  function* IndexedAccessType(node) {
-    const obj = node.objectType.getText();
-    const key = Collect(node.indexType);
-    yield `Type.Index(${obj}, ${key})`;
-  }
-  function* ExpressionWithTypeArguments(node) {
-    const name = Collect(node.expression);
-    const typeArguments = node.typeArguments === void 0 ? [] : node.typeArguments.map((node2) => Collect(node2));
-    return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(", ")})`;
-  }
-  function* TypeParameterDeclaration(node) {
-    yield node.name.getText();
-  }
-  function* ParenthesizedTypeNode(node) {
-    yield Collect(node.type);
-  }
-  function* RestTypeNode(node) {
-    yield `...Type.Rest(${node.type.getText()})`;
-  }
-  function* ConditionalTypeNode(node) {
-    const checkType = Collect(node.checkType);
-    const extendsType = Collect(node.extendsType);
-    const trueType = Collect(node.trueType);
-    const falseType = Collect(node.falseType);
-    yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`;
-  }
-  function* isIndexSignatureDeclaration(node) {
-    yield Collect(node.type);
-  }
-  function* TypeReferenceNode(node) {
-    const name = node.typeName.getText();
-    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(", ")})` : "";
-    if (name === "Date")
-      return yield `Type.Date()`;
-    if (name === "Uint8Array")
-      return yield `Type.Uint8Array()`;
-    if (name === "String")
-      return yield `Type.String()`;
-    if (name === "Number")
-      return yield `Type.Number()`;
-    if (name === "Boolean")
-      return yield `Type.Boolean()`;
-    if (name === "Function")
-      return yield `Type.Function([], Type.Unknown())`;
-    if (name === "Array")
-      return yield `Type.Array${args}`;
-    if (name === "Record")
-      return yield `Type.Record${args}`;
-    if (name === "Partial")
-      return yield `Type.Partial${args}`;
-    if (name === "Required")
-      return yield `Type.Required${args}`;
-    if (name === "Omit")
-      return yield `Type.Omit${args}`;
-    if (name === "Pick")
-      return yield `Type.Pick${args}`;
-    if (name === "Promise")
-      return yield `Type.Promise${args}`;
-    if (name === "ReturnType")
-      return yield `Type.ReturnType${args}`;
-    if (name === "InstanceType")
-      return yield `Type.InstanceType${args}`;
-    if (name === "Parameters")
-      return yield `Type.Parameters${args}`;
-    if (name === "AsyncIterableIterator")
-      return yield `Type.AsyncIterator${args}`;
-    if (name === "IterableIterator")
-      return yield `Type.Iterator${args}`;
-    if (name === "ConstructorParameters")
-      return yield `Type.ConstructorParameters${args}`;
-    if (name === "Exclude")
-      return yield `Type.Exclude${args}`;
-    if (name === "Extract")
-      return yield `Type.Extract${args}`;
-    if (name === "Awaited")
-      return yield `Type.Awaited${args}`;
-    if (name === "Uppercase")
-      return yield `Type.Uppercase${args}`;
-    if (name === "Lowercase")
-      return yield `Type.Lowercase${args}`;
-    if (name === "Capitalize")
-      return yield `Type.Capitalize${args}`;
-    if (name === "Uncapitalize")
-      return yield `Type.Uncapitalize${args}`;
-    if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node))
-      return yield `This`;
-    if (FindTypeName(node.getSourceFile(), name) && args.length === 0) {
-      return yield `${name}${args}`;
-    }
-    if (name in globalThis)
-      return yield `Type.Never()`;
-    return yield `${name}${args}`;
-  }
-  function* LiteralTypeNode(node) {
-    const text = node.getText();
-    if (text === "null")
-      return yield `Type.Null()`;
-    yield InjectOptions(`Type.Literal(${node.getText()})`, ResolveOptions(node));
-  }
-  function* ModuleDeclaration(node) {
-    const export_specifier = IsExport(node) ? "export " : "";
-    const module_specifier = IsNamespace(node) ? "namespace" : "module";
-    yield `${export_specifier}${module_specifier} ${node.name.getText()} {`;
-    yield* Visit(node.body);
-    yield `}`;
-  }
-  function* ModuleBlock(node) {
-    for (const statement of node.statements) {
-      yield* Visit(statement);
-    }
-  }
-  function* FunctionDeclaration(node) {
-  }
-  function* ClassDeclaration(node) {
-  }
-  function Collect(node) {
-    return `${[...Visit(node)].join("")}`;
-  }
-  function* Visit(node) {
-    if (node === void 0)
-      return;
-    if (ts.isArrayTypeNode(node))
-      return yield* ArrayTypeNode(node);
-    if (ts.isBlock(node))
-      return yield* Block(node);
-    if (ts.isClassDeclaration(node))
-      return yield* ClassDeclaration();
-    if (ts.isConditionalTypeNode(node))
-      return yield* ConditionalTypeNode(node);
-    if (ts.isConstructorTypeNode(node))
-      return yield* ConstructorTypeNode(node);
-    if (ts.isEnumDeclaration(node))
-      return yield* EnumDeclaration(node);
-    if (ts.isExpressionWithTypeArguments(node))
-      return yield* ExpressionWithTypeArguments(node);
-    if (ts.isFunctionDeclaration(node))
-      return yield* FunctionDeclaration();
-    if (ts.isFunctionTypeNode(node))
-      return yield* FunctionTypeNode(node);
-    if (ts.isHeritageClause(node))
-      return yield* HeritageClause(node);
-    if (ts.isIndexedAccessTypeNode(node))
-      return yield* IndexedAccessType(node);
-    if (ts.isIndexSignatureDeclaration(node))
-      return yield* isIndexSignatureDeclaration(node);
-    if (ts.isInterfaceDeclaration(node))
-      return yield* InterfaceDeclaration(node);
-    if (ts.isLiteralTypeNode(node))
-      return yield* LiteralTypeNode(node);
-    if (ts.isPropertySignature(node))
-      return yield* PropertySignature(node);
-    if (ts.isModuleDeclaration(node))
-      return yield* ModuleDeclaration(node);
-    if (ts.isIdentifier(node))
-      return yield node.getText();
-    if (ts.isIntersectionTypeNode(node))
-      return yield* IntersectionTypeNode(node);
-    if (ts.isUnionTypeNode(node))
-      return yield* UnionTypeNode(node);
-    if (ts.isMappedTypeNode(node))
-      return yield* MappedTypeNode(node);
-    if (ts.isMethodSignature(node))
-      return yield* MethodSignature(node);
-    if (ts.isModuleBlock(node))
-      return yield* ModuleBlock(node);
-    if (ts.isParameter(node))
-      return yield* Parameter(node);
-    if (ts.isParenthesizedTypeNode(node))
-      return yield* ParenthesizedTypeNode(node);
-    if (ts.isRestTypeNode(node))
-      return yield* RestTypeNode(node);
-    if (ts.isTupleTypeNode(node))
-      return yield* TupleTypeNode(node);
-    if (ts.isTemplateLiteralTypeNode(node))
-      return yield* TemplateLiteralTypeNode(node);
-    if (ts.isTemplateLiteralTypeSpan(node))
-      return yield* TemplateLiteralTypeSpan(node);
-    if (ts.isTemplateHead(node))
-      return yield* TemplateHead(node);
-    if (ts.isTemplateMiddle(node))
-      return yield* TemplateMiddle(node);
-    if (ts.isTemplateTail(node))
-      return yield* TemplateTail(node);
-    if (ts.isThisTypeNode(node))
-      return yield* ThisTypeNode();
-    if (ts.isTypeAliasDeclaration(node))
-      return yield* TypeAliasDeclaration(node);
-    if (ts.isTypeLiteralNode(node))
-      return yield* TypeLiteralNode(node);
-    if (ts.isTypeOperatorNode(node))
-      return yield* TypeOperatorNode(node);
-    if (ts.isTypeParameterDeclaration(node))
-      return yield* TypeParameterDeclaration(node);
-    if (ts.isTypeReferenceNode(node))
-      return yield* TypeReferenceNode(node);
-    if (ts.isSourceFile(node))
-      return yield* SourceFile(node);
-    if (node.kind === ts.SyntaxKind.ExportKeyword)
-      return yield `export`;
-    if (node.kind === ts.SyntaxKind.KeyOfKeyword)
-      return yield `Type.KeyOf()`;
-    if (node.kind === ts.SyntaxKind.NumberKeyword)
-      return yield `Type.Number()`;
-    if (node.kind === ts.SyntaxKind.BigIntKeyword)
-      return yield `Type.BigInt()`;
-    if (node.kind === ts.SyntaxKind.StringKeyword)
-      return yield `Type.String()`;
-    if (node.kind === ts.SyntaxKind.SymbolKeyword)
-      return yield `Type.Symbol()`;
-    if (node.kind === ts.SyntaxKind.BooleanKeyword)
-      return yield `Type.Boolean()`;
-    if (node.kind === ts.SyntaxKind.UndefinedKeyword)
-      return yield `Type.Undefined()`;
-    if (node.kind === ts.SyntaxKind.UnknownKeyword)
-      return yield `Type.Unknown()`;
-    if (node.kind === ts.SyntaxKind.AnyKeyword)
-      return yield `Type.Any()`;
-    if (node.kind === ts.SyntaxKind.NeverKeyword)
-      return yield `Type.Never()`;
-    if (node.kind === ts.SyntaxKind.NullKeyword)
-      return yield `Type.Null()`;
-    if (node.kind === ts.SyntaxKind.VoidKeyword)
-      return yield `Type.Void()`;
-    if (node.kind === ts.SyntaxKind.EndOfFileToken)
-      return;
-    if (node.kind === ts.SyntaxKind.SyntaxList) {
-      for (const child of node.getChildren()) {
-        yield* Visit(child);
-      }
-      return;
-    }
-    console.warn("Unhandled:", ts.SyntaxKind[node.kind], node.getText());
-  }
-  function ImportStatement() {
-    if (!(useImports && useTypeBoxImport))
-      return "";
-    const set = /* @__PURE__ */ new Set(["Type", "Static"]);
-    if (useGenerics) {
-      set.add("TSchema");
-    }
-    if (useOptions) {
-      set.add("SchemaOptions");
-    }
-    if (useCloneType) {
-      set.add("CloneType");
-    }
-    const imports = [...set].join(", ");
-    return `import { ${imports} } from '@sinclair/typebox'`;
-  }
-  function Generate(typescriptCode, options) {
-    var _a, _b, _c;
-    useExportsEverything = (_a = options == null ? void 0 : options.useExportEverything) != null ? _a : false;
-    useIdentifiers = (_b = options == null ? void 0 : options.useIdentifiers) != null ? _b : false;
-    useTypeBoxImport = (_c = options == null ? void 0 : options.useTypeBoxImport) != null ? _c : true;
-    typenames.clear();
-    useImports = false;
-    useOptions = false;
-    useGenerics = false;
-    useCloneType = false;
-    blockLevel = 0;
-    const source = ts.createSourceFile("types.ts", typescriptCode, ts.ScriptTarget.ESNext, true);
-    const declarations = [...Visit(source)].join("\n\n");
-    const imports = ImportStatement();
-    const typescript = [imports, "", "", declarations].join("\n");
-    const assertion = ts.transpileModule(typescript, transpilerOptions);
-    if (assertion.diagnostics && assertion.diagnostics.length > 0) {
-      throw new TypeScriptToTypeBoxError(assertion.diagnostics);
-    }
-    return typescript;
-  }
-  TypeScriptToTypeBox2.Generate = Generate;
+/** Generates TypeBox types from TypeScript code */ export var TypeScriptToTypeBox;
+(function(TypeScriptToTypeBox) {
+    // ------------------------------------------------------------------------------------------------------------
+    // Transpile Options
+    // ------------------------------------------------------------------------------------------------------------
+    const transpilerOptions = {
+        compilerOptions: {
+            strict: true,
+            target: ts.ScriptTarget.ES2022
+        }
+    };
+    // ------------------------------------------------------------------------------------------------------------
+    // Transpile States
+    // ------------------------------------------------------------------------------------------------------------
+    // (auto) tracked on calls to find type name
+    const typenames = new Set();
+    // (auto) tracked for recursive types and used to associate This type references
+    let recursiveDeclaration = null;
+    // (auto) tracked for scoped block level definitions and used to prevent `export` emit when not in global scope.
+    let blockLevel = 0;
+    // (auto) tracked for injecting typebox import statements
+    let useImports = false;
+    // (auto) tracked for injecting JSON schema optios
+    let useOptions = false;
+    // (auto) tracked for injecting TSchema import statements
+    let useGenerics = false;
+    // (auto) tracked for cases where composition requires deep clone
+    let useCloneType = false;
+    // (option) export override to ensure all schematics
+    let useExportsEverything = false;
+    // (option) inject identifiers
+    let useIdentifiers = false;
+    // (option) specifies if typebox imports should be included
+    let useTypeBoxImport = true;
+    // ------------------------------------------------------------------------------------------------------------
+    // AST Query
+    // ------------------------------------------------------------------------------------------------------------
+    function FindRecursiveParent(decl, node) {
+        return ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText() || node.getChildren().some((node)=>FindRecursiveParent(decl, node));
+    }
+    function FindRecursiveThis(node) {
+        return node.getChildren().some((node)=>ts.isThisTypeNode(node) || FindRecursiveThis(node));
+    }
+    function FindTypeName(node, name) {
+        const found = typenames.has(name) || node.getChildren().some((node)=>{
+            return (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) && node.name.getText() === name || FindTypeName(node, name);
+        });
+        if (found) typenames.add(name);
+        return found;
+    }
+    function IsRecursiveType(decl) {
+        const check1 = ts.isTypeAliasDeclaration(decl) ? [
+            decl.type
+        ].some((node)=>FindRecursiveParent(decl, node)) : decl.members.some((node)=>FindRecursiveParent(decl, node));
+        const check2 = ts.isInterfaceDeclaration(decl) && FindRecursiveThis(decl);
+        return check1 || check2;
+    }
+    function IsReadonlyProperty(node) {
+        return node.modifiers !== undefined && node.modifiers.find((modifier)=>modifier.getText() === 'readonly') !== undefined;
+    }
+    function IsOptionalProperty(node) {
+        return node.questionToken !== undefined;
+    }
+    function IsExport(node) {
+        return blockLevel === 0 && (useExportsEverything || node.modifiers !== undefined && node.modifiers.find((modifier)=>modifier.getText() === 'export') !== undefined);
+    }
+    function IsNamespace(node) {
+        return node.flags === ts.NodeFlags.Namespace;
+    }
+    // ------------------------------------------------------------------------------------------------------------
+    // Options
+    // ------------------------------------------------------------------------------------------------------------
+    function ResolveJsDocComment(node) {
+        const content = node.getFullText().trim();
+        if (node.kind === ts.SyntaxKind.LiteralType) {
+            if (content.startsWith('/**')) {
+                // add a new line for JsDoc to parse properly
+                return content.slice(0, content.lastIndexOf('*/') + 2).replace(/\*+\/$/, '\n$0');
+            } else {
+                return '';
+            }
+        }
+        const indices = [
+            content.indexOf('/**'),
+            content.indexOf('type'),
+            content.indexOf('interface')
+        ].map((n)=>n === -1 ? Infinity : n);
+        if (indices[0] === -1 || indices[1] < indices[0] || indices[2] < indices[0]) return ''; // no comment or declaration before comment
+        for(let i = indices[0]; i < content.length; i++){
+            if (content[i] === '*' && content[i + 1] === '/') return content.slice(0, i + 2);
+        }
+        return '';
+    }
+    function ResolveOptions(node) {
+        const content = ResolveJsDocComment(node);
+        return JsDoc.Parse(content);
+    }
+    // ------------------------------------------------------------------------------------------------------------
+    // Identifiers
+    // ------------------------------------------------------------------------------------------------------------
+    function ResolveIdentifier(node) {
+        function* resolve(node) {
+            if (node.parent) yield* resolve(node.parent);
+            if (ts.isModuleDeclaration(node)) yield node.name.getText();
+        }
+        return [
+            ...resolve(node),
+            node.name.getText()
+        ].join('.');
+    }
+    function UnwrapModifier(type) {
+        for(let i = 0; i < type.length; i++)if (type[i] === '(') return type.slice(i + 1, type.length - 1);
+        return type;
+    }
+    // Note: This function is only called when 'useIdentifiers' is true. What we're trying to achieve with
+    // identifier injection is a referential type model over the default inline model. For the purposes of
+    // code generation, we tend to prefer referential types as these can be both inlined or referenced in
+    // the codegen target; and where different targets may have different referential requirements. It
+    // should be possible to implement a more robust injection mechanism however. For review.
+    // prettier-ignore
+    function InjectOptions(type, options) {
+        if (globalThis.Object.keys(options).length === 0) return type;
+        // unwrap for modifiers
+        if (type.indexOf('Type.ReadonlyOptional') === 0) return `Type.ReadonlyOptional( ${InjectOptions(UnwrapModifier(type), options)} )`;
+        if (type.indexOf('Type.Readonly') === 0) return `Type.Readonly( ${InjectOptions(UnwrapModifier(type), options)} )`;
+        if (type.indexOf('Type.Optional') === 0) return `Type.Optional( ${InjectOptions(UnwrapModifier(type), options)} )`;
+        const encoded = JSON.stringify(options);
+        // indexer type
+        if (type.lastIndexOf(']') === type.length - 1) useCloneType = true;
+        if (type.lastIndexOf(']') === type.length - 1) return `CloneType(${type}, ${encoded})`;
+        // referenced type
+        if (type.indexOf('(') === -1) {
+            useCloneType = true;
+            return `CloneType(${type}, ${encoded})`;
+        }
+        if (type.lastIndexOf('()') === type.length - 2) return type.slice(0, type.length - 1) + `${encoded})`;
+        if (type.lastIndexOf('})') === type.length - 2) return type.slice(0, type.length - 1) + `, ${encoded})`;
+        if (type.lastIndexOf('])') === type.length - 2) return type.slice(0, type.length - 1) + `, ${encoded})`;
+        if (type.lastIndexOf(')') === type.length - 1) return type.slice(0, type.length - 1) + `, ${encoded})`;
+        return type;
+    }
+    // ------------------------------------------------------------------------------------------------------------
+    // Nodes
+    // ------------------------------------------------------------------------------------------------------------
+    function* SourceFile(node) {
+        for (const next of node.getChildren()){
+            yield* Visit(next);
+        }
+    }
+    function* PropertySignature(node) {
+        const [readonly, optional] = [
+            IsReadonlyProperty(node),
+            IsOptionalProperty(node)
+        ];
+        const options = ResolveOptions(node);
+        const type_0 = Collect(node.type);
+        const type_1 = InjectOptions(type_0, options);
+        if (readonly && optional) {
+            return yield `${node.name.getText()}: Type.ReadonlyOptional(${type_1})`;
+        } else if (readonly) {
+            return yield `${node.name.getText()}: Type.Readonly(${type_1})`;
+        } else if (optional) {
+            return yield `${node.name.getText()}: Type.Optional(${type_1})`;
+        } else {
+            return yield `${node.name.getText()}: ${type_1}`;
+        }
+    }
+    function* ArrayTypeNode(node) {
+        const type = Collect(node.elementType);
+        yield `Type.Array(${type})`;
+    }
+    function* Block(node) {
+        blockLevel += 1;
+        const statments = node.statements.map((statement)=>Collect(statement)).join('\n\n');
+        blockLevel -= 1;
+        yield `{\n${statments}\n}`;
+    }
+    function* TupleTypeNode(node) {
+        const types = node.elements.map((type)=>Collect(type)).join(',\n');
+        yield `Type.Tuple([\n${types}\n])`;
+    }
+    function* UnionTypeNode(node) {
+        const types = node.types.map((type)=>Collect(type)).join(',\n');
+        yield `Type.Union([\n${types}\n])`;
+    }
+    function* MappedTypeNode(node) {
+        const K = Collect(node.typeParameter);
+        const T = Collect(node.type);
+        const C = Collect(node.typeParameter.constraint);
+        const readonly = node.readonlyToken !== undefined;
+        const optional = node.questionToken !== undefined;
+        const readonly_subtractive = readonly && ts.isMinusToken(node.readonlyToken);
+        const optional_subtractive = optional && ts.isMinusToken(node.questionToken);
+        // prettier-ignore
+        return yield readonly && optional ? readonly_subtractive && optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false), false))` : readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}), false))` : optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false)))` : `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T})))` : readonly ? readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Readonly(${T}))` : optional ? optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Optional(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Optional(${T}))` : `Type.Mapped(${C}, ${K} => ${T})`;
+    }
+    function* MethodSignature(node) {
+        const parameters = node.parameters.map((parameter)=>parameter.dotDotDotToken !== undefined ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)).join(', ');
+        const returnType = node.type === undefined ? `Type.Unknown()` : Collect(node.type);
+        yield `${node.name.getText()}: Type.Function([${parameters}], ${returnType})`;
+    }
+    // prettier-ignore
+    function* TemplateLiteralTypeNode(node) {
+        const collect = node.getChildren().map((node)=>Collect(node)).join('');
+        yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])` // can't remove trailing here
+        ;
+    }
+    // prettier-ignore
+    function* TemplateLiteralTypeSpan(node) {
+        const collect = node.getChildren().map((node)=>Collect(node)).join(', ');
+        if (collect.length > 0) yield `${collect}`;
+    }
+    function* TemplateHead(node) {
+        if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;
+    }
+    function* TemplateMiddle(node) {
+        if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;
+    }
+    function* TemplateTail(node) {
+        if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;
+    }
+    function* ThisTypeNode(node) {
+        yield `This`;
+    }
+    function* IntersectionTypeNode(node) {
+        const types = node.types.map((type)=>Collect(type)).join(',\n');
+        yield `Type.Intersect([\n${types}\n])`;
+    }
+    function* TypeOperatorNode(node) {
+        if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
+            const type = Collect(node.type);
+            yield `Type.KeyOf(${type})`;
+        }
+        if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+            yield `Type.Readonly(${Collect(node.type)})`;
+        }
+    }
+    function* Parameter(node) {
+        yield Collect(node.type);
+    }
+    function* FunctionTypeNode(node) {
+        const parameters = node.parameters.map((parameter)=>parameter.dotDotDotToken !== undefined ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)).join(', ');
+        const returns = Collect(node.type);
+        yield `Type.Function([${parameters}], ${returns})`;
+    }
+    function* ConstructorTypeNode(node) {
+        const parameters = node.parameters.map((param)=>Collect(param)).join(', ');
+        const returns = Collect(node.type);
+        yield `Type.Constructor([${parameters}], ${returns})`;
+    }
+    function* EnumDeclaration(node) {
+        useImports = true;
+        const exports = IsExport(node) ? 'export ' : '';
+        const members = node.members.map((member)=>member.getText()).join(', ');
+        const enumType = `${exports}enum Enum${node.name.getText()} { ${members} }`;
+        const staticType = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+        const type = `${exports}const ${node.name.getText()} = Type.Enum(Enum${node.name.getText()})`;
+        yield [
+            enumType,
+            '',
+            staticType,
+            type
+        ].join('\n');
+    }
+    function PropertiesFromTypeElementArray(members) {
+        const properties = members.filter((member)=>!ts.isIndexSignatureDeclaration(member));
+        const indexers = members.filter((member)=>ts.isIndexSignatureDeclaration(member));
+        const propertyCollect = properties.map((property)=>Collect(property)).join(',\n');
+        const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : '';
+        if (properties.length === 0 && indexer.length > 0) {
+            return `{},\n{\nadditionalProperties: ${indexer}\n }`;
+        } else if (properties.length > 0 && indexer.length > 0) {
+            return `{\n${propertyCollect}\n},\n{\nadditionalProperties: ${indexer}\n }`;
+        } else {
+            return `{\n${propertyCollect}\n}`;
+        }
+    }
+    function* TypeLiteralNode(node) {
+        const members = PropertiesFromTypeElementArray(node.members);
+        yield* `Type.Object(${members})`;
+    }
+    function* InterfaceDeclaration(node) {
+        useImports = true;
+        const isRecursiveType = IsRecursiveType(node);
+        if (isRecursiveType) recursiveDeclaration = node;
+        const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node)=>Collect(node)) : [];
+        if (node.typeParameters) {
+            useGenerics = true;
+            const exports = IsExport(node) ? 'export ' : '';
+            const identifier = ResolveIdentifier(node);
+            const options = useIdentifiers ? {
+                ...ResolveOptions(node),
+                $id: identifier
+            } : {
+                ...ResolveOptions(node)
+            };
+            const constraints = node.typeParameters.map((param)=>`${Collect(param)} extends TSchema`).join(', ');
+            const parameters = node.typeParameters.map((param)=>`${Collect(param)}: ${Collect(param)}`).join(', ');
+            const members = PropertiesFromTypeElementArray(node.members);
+            // const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+            // const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
+            const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
+            const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(', ')}, ${rawTypeExpression}])`;
+            const type = InjectOptions(typeExpression, options);
+            const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`;
+            yield `${typeDeclaration}`;
+        } else {
+            const exports = IsExport(node) ? 'export ' : '';
+            const identifier = ResolveIdentifier(node);
+            const options = useIdentifiers ? {
+                ...ResolveOptions(node),
+                $id: identifier
+            } : {
+                ...ResolveOptions(node)
+            };
+            const members = PropertiesFromTypeElementArray(node.members);
+            const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+            const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
+            const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(', ')}, ${rawTypeExpression}])`;
+            const type = InjectOptions(typeExpression, options);
+            const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`;
+            yield `${staticDeclaration}\n${typeDeclaration}`;
+        }
+        recursiveDeclaration = null;
+    }
+    function* TypeAliasDeclaration(node) {
+        useImports = true;
+        const isRecursiveType = IsRecursiveType(node);
+        if (isRecursiveType) recursiveDeclaration = node;
+        // Generics case
+        if (node.typeParameters) {
+            useGenerics = true;
+            const exports = IsExport(node) ? 'export ' : '';
+            const options = useIdentifiers ? {
+                $id: ResolveIdentifier(node)
+            } : {};
+            const constraints = node.typeParameters.map((param)=>`${Collect(param)} extends TSchema`).join(', ');
+            const parameters = node.typeParameters.map((param)=>`${Collect(param)}: ${Collect(param)}`).join(', ');
+            const type_0 = Collect(node.type);
+            const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
+            const type_2 = InjectOptions(type_1, options);
+            // const names = node.typeParameters.map((param) => Collect(param)).join(', ')
+            // const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
+            const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type_2}`;
+            yield `${typeDeclaration}`;
+        } else {
+            const exports = IsExport(node) ? 'export ' : '';
+            const options = useIdentifiers ? {
+                $id: ResolveIdentifier(node),
+                ...ResolveOptions(node)
+            } : {
+                ...ResolveOptions(node)
+            };
+            const type_0 = Collect(node.type);
+            const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
+            const type_2 = InjectOptions(type_1, options);
+            const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+            const typeDeclaration = `${exports}const ${node.name.getText()} = ${type_2}`;
+            yield `${staticDeclaration}\n${typeDeclaration}`;
+        }
+        recursiveDeclaration = null;
+    }
+    function* HeritageClause(node) {
+        // Consideration: This may be better expressed as a heritage type (for review)
+        const types = node.types.map((node)=>Collect(node));
+        if (types.length === 1) return yield types[0];
+        // yield `Type.Composite([${types.join(', ')}])`
+        // Note: Heritage clauses are only used in extends cases, and where Composite
+        // is the exterior type. These types will be prepended to the Composite array.
+        yield types.join(', ');
+    }
+    function* IndexedAccessType(node) {
+        const obj = node.objectType.getText();
+        const key = Collect(node.indexType);
+        yield `Type.Index(${obj}, ${key})`;
+    }
+    function* ExpressionWithTypeArguments(node) {
+        const name = Collect(node.expression);
+        const typeArguments = node.typeArguments === undefined ? [] : node.typeArguments.map((node)=>Collect(node));
+        // todo: default type argument (resolve `= number` from `type Foo<T = number>`)
+        return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(', ')})`;
+    }
+    function* TypeParameterDeclaration(node) {
+        yield node.name.getText();
+    }
+    function* ParenthesizedTypeNode(node) {
+        yield Collect(node.type);
+    }
+    function* RestTypeNode(node) {
+        yield `...Type.Rest(${node.type.getText()})`;
+    }
+    function* ConditionalTypeNode(node) {
+        const checkType = Collect(node.checkType);
+        const extendsType = Collect(node.extendsType);
+        const trueType = Collect(node.trueType);
+        const falseType = Collect(node.falseType);
+        yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`;
+    }
+    function* isIndexSignatureDeclaration(node) {
+        // note: we ignore the key and just return the type. this is a mismatch between
+        // object and record types. Address in TypeBox by unifying validation paths
+        // for objects and record types.
+        yield Collect(node.type);
+    }
+    function* TypeReferenceNode(node) {
+        const name = node.typeName.getText();
+        const args = node.typeArguments ? `(${node.typeArguments.map((type)=>Collect(type)).join(', ')})` : '';
+        // --------------------------------------------------------------
+        // Instance Types
+        // --------------------------------------------------------------
+        if (name === 'Date') return yield `Type.Date()`;
+        if (name === 'Uint8Array') return yield `Type.Uint8Array()`;
+        if (name === 'String') return yield `Type.String()`;
+        if (name === 'Number') return yield `Type.Number()`;
+        if (name === 'Boolean') return yield `Type.Boolean()`;
+        if (name === 'Function') return yield `Type.Function([], Type.Unknown())`;
+        // --------------------------------------------------------------
+        // Types
+        // --------------------------------------------------------------
+        if (name === 'Array') return yield `Type.Array${args}`;
+        if (name === 'Record') return yield `Type.Record${args}`;
+        if (name === 'Partial') return yield `Type.Partial${args}`;
+        if (name === 'Required') return yield `Type.Required${args}`;
+        if (name === 'Omit') return yield `Type.Omit${args}`;
+        if (name === 'Pick') return yield `Type.Pick${args}`;
+        if (name === 'Promise') return yield `Type.Promise${args}`;
+        if (name === 'ReturnType') return yield `Type.ReturnType${args}`;
+        if (name === 'InstanceType') return yield `Type.InstanceType${args}`;
+        if (name === 'Parameters') return yield `Type.Parameters${args}`;
+        if (name === 'AsyncIterableIterator') return yield `Type.AsyncIterator${args}`;
+        if (name === 'IterableIterator') return yield `Type.Iterator${args}`;
+        if (name === 'ConstructorParameters') return yield `Type.ConstructorParameters${args}`;
+        if (name === 'Exclude') return yield `Type.Exclude${args}`;
+        if (name === 'Extract') return yield `Type.Extract${args}`;
+        if (name === 'Awaited') return yield `Type.Awaited${args}`;
+        if (name === 'Uppercase') return yield `Type.Uppercase${args}`;
+        if (name === 'Lowercase') return yield `Type.Lowercase${args}`;
+        if (name === 'Capitalize') return yield `Type.Capitalize${args}`;
+        if (name === 'Uncapitalize') return yield `Type.Uncapitalize${args}`;
+        if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) return yield `This`;
+        if (FindTypeName(node.getSourceFile(), name) && args.length === 0 /** non-resolvable */ ) {
+            return yield `${name}${args}`;
+        }
+        if (name in globalThis) return yield `Type.Never()`;
+        return yield `${name}${args}`;
+    }
+    function* LiteralTypeNode(node) {
+        const text = node.getText();
+        if (text === 'null') return yield `Type.Null()`;
+        yield InjectOptions(`Type.Literal(${node.getText()})`, ResolveOptions(node));
+    }
+    function* ModuleDeclaration(node) {
+        const export_specifier = IsExport(node) ? 'export ' : '';
+        const module_specifier = IsNamespace(node) ? 'namespace' : 'module';
+        yield `${export_specifier}${module_specifier} ${node.name.getText()} {`;
+        yield* Visit(node.body);
+        yield `}`;
+    }
+    function* ModuleBlock(node) {
+        for (const statement of node.statements){
+            yield* Visit(statement);
+        }
+    }
+    function* FunctionDeclaration(node) {
+    // ignore
+    }
+    function* ClassDeclaration(node) {
+    // ignore
+    }
+    function Collect(node) {
+        return `${[
+            ...Visit(node)
+        ].join('')}`;
+    }
+    function* Visit(node) {
+        if (node === undefined) return;
+        if (ts.isArrayTypeNode(node)) return yield* ArrayTypeNode(node);
+        if (ts.isBlock(node)) return yield* Block(node);
+        if (ts.isClassDeclaration(node)) return yield* ClassDeclaration(node);
+        if (ts.isConditionalTypeNode(node)) return yield* ConditionalTypeNode(node);
+        if (ts.isConstructorTypeNode(node)) return yield* ConstructorTypeNode(node);
+        if (ts.isEnumDeclaration(node)) return yield* EnumDeclaration(node);
+        if (ts.isExpressionWithTypeArguments(node)) return yield* ExpressionWithTypeArguments(node);
+        if (ts.isFunctionDeclaration(node)) return yield* FunctionDeclaration(node);
+        if (ts.isFunctionTypeNode(node)) return yield* FunctionTypeNode(node);
+        if (ts.isHeritageClause(node)) return yield* HeritageClause(node);
+        if (ts.isIndexedAccessTypeNode(node)) return yield* IndexedAccessType(node);
+        if (ts.isIndexSignatureDeclaration(node)) return yield* isIndexSignatureDeclaration(node);
+        if (ts.isInterfaceDeclaration(node)) return yield* InterfaceDeclaration(node);
+        if (ts.isLiteralTypeNode(node)) return yield* LiteralTypeNode(node);
+        if (ts.isPropertySignature(node)) return yield* PropertySignature(node);
+        if (ts.isModuleDeclaration(node)) return yield* ModuleDeclaration(node);
+        if (ts.isIdentifier(node)) return yield node.getText();
+        if (ts.isIntersectionTypeNode(node)) return yield* IntersectionTypeNode(node);
+        if (ts.isUnionTypeNode(node)) return yield* UnionTypeNode(node);
+        if (ts.isMappedTypeNode(node)) return yield* MappedTypeNode(node);
+        if (ts.isMethodSignature(node)) return yield* MethodSignature(node);
+        if (ts.isModuleBlock(node)) return yield* ModuleBlock(node);
+        if (ts.isParameter(node)) return yield* Parameter(node);
+        if (ts.isParenthesizedTypeNode(node)) return yield* ParenthesizedTypeNode(node);
+        if (ts.isRestTypeNode(node)) return yield* RestTypeNode(node);
+        if (ts.isTupleTypeNode(node)) return yield* TupleTypeNode(node);
+        if (ts.isTemplateLiteralTypeNode(node)) return yield* TemplateLiteralTypeNode(node);
+        if (ts.isTemplateLiteralTypeSpan(node)) return yield* TemplateLiteralTypeSpan(node);
+        if (ts.isTemplateHead(node)) return yield* TemplateHead(node);
+        if (ts.isTemplateMiddle(node)) return yield* TemplateMiddle(node);
+        if (ts.isTemplateTail(node)) return yield* TemplateTail(node);
+        if (ts.isThisTypeNode(node)) return yield* ThisTypeNode(node);
+        if (ts.isTypeAliasDeclaration(node)) return yield* TypeAliasDeclaration(node);
+        if (ts.isTypeLiteralNode(node)) return yield* TypeLiteralNode(node);
+        if (ts.isTypeOperatorNode(node)) return yield* TypeOperatorNode(node);
+        if (ts.isTypeParameterDeclaration(node)) return yield* TypeParameterDeclaration(node);
+        if (ts.isTypeReferenceNode(node)) return yield* TypeReferenceNode(node);
+        if (ts.isSourceFile(node)) return yield* SourceFile(node);
+        if (node.kind === ts.SyntaxKind.ExportKeyword) return yield `export`;
+        if (node.kind === ts.SyntaxKind.KeyOfKeyword) return yield `Type.KeyOf()`;
+        if (node.kind === ts.SyntaxKind.NumberKeyword) return yield `Type.Number()`;
+        if (node.kind === ts.SyntaxKind.BigIntKeyword) return yield `Type.BigInt()`;
+        if (node.kind === ts.SyntaxKind.StringKeyword) return yield `Type.String()`;
+        if (node.kind === ts.SyntaxKind.SymbolKeyword) return yield `Type.Symbol()`;
+        if (node.kind === ts.SyntaxKind.BooleanKeyword) return yield `Type.Boolean()`;
+        if (node.kind === ts.SyntaxKind.UndefinedKeyword) return yield `Type.Undefined()`;
+        if (node.kind === ts.SyntaxKind.UnknownKeyword) return yield `Type.Unknown()`;
+        if (node.kind === ts.SyntaxKind.AnyKeyword) return yield `Type.Any()`;
+        if (node.kind === ts.SyntaxKind.NeverKeyword) return yield `Type.Never()`;
+        if (node.kind === ts.SyntaxKind.NullKeyword) return yield `Type.Null()`;
+        if (node.kind === ts.SyntaxKind.VoidKeyword) return yield `Type.Void()`;
+        if (node.kind === ts.SyntaxKind.EndOfFileToken) return;
+        if (node.kind === ts.SyntaxKind.SyntaxList) {
+            for (const child of node.getChildren()){
+                yield* Visit(child);
+            }
+            return;
+        }
+        console.warn('Unhandled:', ts.SyntaxKind[node.kind], node.getText());
+    }
+    function ImportStatement() {
+        if (!(useImports && useTypeBoxImport)) return '';
+        const set = new Set([
+            'Type',
+            'Static'
+        ]);
+        if (useGenerics) {
+            set.add('TSchema');
+        }
+        if (useOptions) {
+            set.add('SchemaOptions');
+        }
+        if (useCloneType) {
+            set.add('CloneType');
+        }
+        const imports = [
+            ...set
+        ].join(', ');
+        return `import { ${imports} } from '@sinclair/typebox'`;
+    }
+    function Generate(typescriptCode, options) {
+        useExportsEverything = options?.useExportEverything ?? false;
+        useIdentifiers = options?.useIdentifiers ?? false;
+        useTypeBoxImport = options?.useTypeBoxImport ?? true;
+        typenames.clear();
+        useImports = false;
+        useOptions = false;
+        useGenerics = false;
+        useCloneType = false;
+        blockLevel = 0;
+        const source = ts.createSourceFile('types.ts', typescriptCode, ts.ScriptTarget.ESNext, true);
+        const declarations = [
+            ...Visit(source)
+        ].join('\n\n');
+        const imports = ImportStatement();
+        const typescript = [
+            imports,
+            '',
+            '',
+            declarations
+        ].join('\n');
+        const assertion = ts.transpileModule(typescript, transpilerOptions);
+        if (assertion.diagnostics && assertion.diagnostics.length > 0) {
+            throw new TypeScriptToTypeBoxError(assertion.diagnostics);
+        }
+        return typescript;
+    }
+    TypeScriptToTypeBox.Generate = Generate;
 })(TypeScriptToTypeBox || (TypeScriptToTypeBox = {}));
 
-export { TypeScriptToTypeBox, TypeScriptToTypeBoxError };
-//# sourceMappingURL=typescript-to-typebox.js.map
+//# sourceMappingURL=typescript-to-typebox.js.map