@wener/utils 1.1.47 → 1.1.49

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/typescript/typescript-to-typebox.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-codegen\n\nThe MIT License (MIT)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\nimport * as ts from 'typescript';\nimport { JsDoc } from '../common/jsdoc';\n\nexport class TypeScriptToTypeBoxError extends Error {\n  constructor(public readonly diagnostics: ts.Diagnostic[]) {\n    super('');\n  }\n}\n// --------------------------------------------------------------------------\n// TypeScriptToTypeBox\n// --------------------------------------------------------------------------\n\nexport interface TypeScriptToTypeBoxOptions {\n  /**\n   * Setting this to true will ensure all types are exports as const values. This setting is\n   * used by the TypeScriptToTypeBoxModel to gather TypeBox definitions during runtime eval\n   * pass. The default is false\n   */\n  useExportEverything?: boolean;\n  /**\n   * Specifies if the output code should specify a default `import` statement. For TypeScript\n   * generated code this is typically desirable, but for Model generated code, the `Type`\n   * build is passed in into scope as a variable. The default is true.\n   */\n  useTypeBoxImport?: boolean;\n  /**\n   * Specifies if the output types should include an identifier associated with the assigned\n   * variable name. This is useful for remapping model types to targets, but optional for\n   * for TypeBox which can operate on vanilla JS references. The default is false.\n   */\n  useIdentifiers?: boolean;\n}\n/** Generates TypeBox types from TypeScript code */\nexport namespace TypeScriptToTypeBox {\n  // ------------------------------------------------------------------------------------------------------------\n  // Transpile Options\n  // ------------------------------------------------------------------------------------------------------------\n  const transpilerOptions: ts.TranspileOptions = {\n    compilerOptions: {\n      strict: true,\n      target: ts.ScriptTarget.ES2022,\n    },\n  };\n  // ------------------------------------------------------------------------------------------------------------\n  // Transpile States\n  // ------------------------------------------------------------------------------------------------------------\n  // (auto) tracked on calls to find type name\n  const typenames = new Set<string>();\n  // (auto) tracked for recursive types and used to associate This type references\n  let recursiveDeclaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration | null = null;\n  // (auto) tracked for scoped block level definitions and used to prevent `export` emit when not in global scope.\n  let blockLevel: number = 0;\n  // (auto) tracked for injecting typebox import statements\n  let useImports = false;\n  // (auto) tracked for injecting JSON schema optios\n  let useOptions = false;\n  // (auto) tracked for injecting TSchema import statements\n  let useGenerics = false;\n  // (auto) tracked for cases where composition requires deep clone\n  let useCloneType = false;\n  // (option) export override to ensure all schematics\n  let useExportsEverything = false;\n  // (option) inject identifiers\n  let useIdentifiers = false;\n  // (option) specifies if typebox imports should be included\n  let useTypeBoxImport = true;\n  // ------------------------------------------------------------------------------------------------------------\n  // AST Query\n  // ------------------------------------------------------------------------------------------------------------\n  function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {\n    return (\n      (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) ||\n      node.getChildren().some((node) => FindRecursiveParent(decl, node))\n    );\n  }\n  function FindRecursiveThis(node: ts.Node): boolean {\n    return node.getChildren().some((node) => ts.isThisTypeNode(node) || FindRecursiveThis(node));\n  }\n  function FindTypeName(node: ts.Node, name: string): boolean {\n    const found =\n      typenames.has(name) ||\n      node.getChildren().some((node) => {\n        return (\n          ((ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) && node.name.getText() === name) ||\n          FindTypeName(node, name)\n        );\n      });\n    if (found) typenames.add(name);\n    return found;\n  }\n  function IsRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {\n    const check1 = ts.isTypeAliasDeclaration(decl)\n      ? [decl.type].some((node) => FindRecursiveParent(decl, node))\n      : decl.members.some((node) => FindRecursiveParent(decl, node));\n    const check2 = ts.isInterfaceDeclaration(decl) && FindRecursiveThis(decl);\n    return check1 || check2;\n  }\n  function IsReadonlyProperty(node: ts.PropertySignature): boolean {\n    return (\n      node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined\n    );\n  }\n  function IsOptionalProperty(node: ts.PropertySignature) {\n    return node.questionToken !== undefined;\n  }\n  function IsExport(\n    node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration,\n  ): boolean {\n    return (\n      blockLevel === 0 &&\n      (useExportsEverything ||\n        (node.modifiers !== undefined &&\n          node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined))\n    );\n  }\n  function IsNamespace(node: ts.ModuleDeclaration) {\n    return node.flags === ts.NodeFlags.Namespace;\n  }\n  // ------------------------------------------------------------------------------------------------------------\n  // Options\n  // ------------------------------------------------------------------------------------------------------------\n  function ResolveJsDocComment(\n    node: ts.TypeAliasDeclaration | ts.PropertySignature | ts.InterfaceDeclaration | ts.LiteralTypeNode,\n  ): string {\n    const content = node.getFullText().trim();\n    if (node.kind === ts.SyntaxKind.LiteralType) {\n      if (content.startsWith('/**')) {\n        // add a new line for JsDoc to parse properly\n        return content.slice(0, content.lastIndexOf('*/') + 2).replace(/\\*+\\/$/, '\\n$0');\n      } else {\n        return '';\n      }\n    }\n    const indices = [content.indexOf('/**'), content.indexOf('type'), content.indexOf('interface')].map((n) =>\n      n === -1 ? Infinity : n,\n    );\n    if (indices[0] === -1 || indices[1] < indices[0] || indices[2] < indices[0]) return ''; // no comment or declaration before comment\n    for (let i = indices[0]; i < content.length; i++) {\n      if (content[i] === '*' && content[i + 1] === '/') return content.slice(0, i + 2);\n    }\n    return '';\n  }\n  function ResolveOptions(\n    node: ts.TypeAliasDeclaration | ts.PropertySignature | ts.InterfaceDeclaration | ts.LiteralTypeNode,\n  ): Record<string, unknown> {\n    const content = ResolveJsDocComment(node);\n    return JsDoc.Parse(content);\n  }\n  // ------------------------------------------------------------------------------------------------------------\n  // Identifiers\n  // ------------------------------------------------------------------------------------------------------------\n  function ResolveIdentifier(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {\n    function* resolve(node: ts.Node): IterableIterator<string> {\n      if (node.parent) yield* resolve(node.parent);\n      if (ts.isModuleDeclaration(node)) yield node.name.getText();\n    }\n    return [...resolve(node), node.name.getText()].join('.');\n  }\n  function UnwrapModifier(type: string) {\n    for (let i = 0; i < type.length; i++) if (type[i] === '(') return type.slice(i + 1, type.length - 1);\n    return type;\n  }\n  // Note: This function is only called when 'useIdentifiers' is true. What we're trying to achieve with\n  // identifier injection is a referential type model over the default inline model. For the purposes of\n  // code generation, we tend to prefer referential types as these can be both inlined or referenced in\n  // the codegen target; and where different targets may have different referential requirements. It\n  // should be possible to implement a more robust injection mechanism however. For review.\n  // prettier-ignore\n  function InjectOptions(type: string, options: Record<string, unknown>): string {\n    if (globalThis.Object.keys(options).length === 0) return type\n    // unwrap for modifiers\n    if (type.indexOf('Type.ReadonlyOptional') === 0) return `Type.ReadonlyOptional( ${InjectOptions(UnwrapModifier(type), options)} )`\n    if (type.indexOf('Type.Readonly') === 0) return `Type.Readonly( ${InjectOptions(UnwrapModifier(type), options)} )`\n    if (type.indexOf('Type.Optional') === 0) return `Type.Optional( ${InjectOptions(UnwrapModifier(type), options)} )`\n    const encoded = JSON.stringify(options)\n    // indexer type\n    if (type.lastIndexOf(']') === type.length - 1) useCloneType = true\n    if (type.lastIndexOf(']') === type.length - 1) return `CloneType(${type}, ${encoded})`\n    // referenced type\n    if (type.indexOf('(') === -1) { useCloneType = true; return `CloneType(${type}, ${encoded})` }\n    if (type.lastIndexOf('()') === type.length - 2) return type.slice(0, type.length - 1) + `${encoded})`\n    if (type.lastIndexOf('})') === type.length - 2) return type.slice(0, type.length - 1) + `, ${encoded})`\n    if (type.lastIndexOf('])') === type.length - 2) return type.slice(0, type.length - 1) + `, ${encoded})`\n    if (type.lastIndexOf(')') === type.length - 1) return type.slice(0, type.length - 1) + `, ${encoded})`\n    return type\n  }\n  // ------------------------------------------------------------------------------------------------------------\n  // Nodes\n  // ------------------------------------------------------------------------------------------------------------\n  function* SourceFile(node: ts.SourceFile): IterableIterator<string> {\n    for (const next of node.getChildren()) {\n      yield* Visit(next);\n    }\n  }\n  function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {\n    const [readonly, optional] = [IsReadonlyProperty(node), IsOptionalProperty(node)];\n    const options = ResolveOptions(node);\n    const type_0 = Collect(node.type);\n    const type_1 = InjectOptions(type_0, options);\n    if (readonly && optional) {\n      return yield `${node.name.getText()}: Type.ReadonlyOptional(${type_1})`;\n    } else if (readonly) {\n      return yield `${node.name.getText()}: Type.Readonly(${type_1})`;\n    } else if (optional) {\n      return yield `${node.name.getText()}: Type.Optional(${type_1})`;\n    } else {\n      return yield `${node.name.getText()}: ${type_1}`;\n    }\n  }\n  function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {\n    const type = Collect(node.elementType);\n    yield `Type.Array(${type})`;\n  }\n  function* Block(node: ts.Block): IterableIterator<string> {\n    blockLevel += 1;\n    const statments = node.statements.map((statement) => Collect(statement)).join('\\n\\n');\n    blockLevel -= 1;\n    yield `{\\n${statments}\\n}`;\n  }\n  function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {\n    const types = node.elements.map((type) => Collect(type)).join(',\\n');\n    yield `Type.Tuple([\\n${types}\\n])`;\n  }\n  function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {\n    const types = node.types.map((type) => Collect(type)).join(',\\n');\n    yield `Type.Union([\\n${types}\\n])`;\n  }\n  function* MappedTypeNode(node: ts.MappedTypeNode): IterableIterator<string> {\n    const K = Collect(node.typeParameter);\n    const T = Collect(node.type);\n    const C = Collect(node.typeParameter.constraint);\n    const readonly = node.readonlyToken !== undefined;\n    const optional = node.questionToken !== undefined;\n    const readonly_subtractive = readonly && ts.isMinusToken(node.readonlyToken);\n    const optional_subtractive = optional && ts.isMinusToken(node.questionToken);\n    // prettier-ignore\n    return yield (\n      (readonly && optional) ? (\n        (readonly_subtractive && optional_subtractive) ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false), false))` :\n        (readonly_subtractive) ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}), false))` :\n        (optional_subtractive) ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false)))` :\n        `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T})))`\n      ) : (readonly) ? (\n        readonly_subtractive\n          ? `Type.Mapped(${C}, ${K} => Type.Readonly(${T}, false))`\n          : `Type.Mapped(${C}, ${K} => Type.Readonly(${T}))`\n      ) : (optional) ? (\n        optional_subtractive\n          ? `Type.Mapped(${C}, ${K} => Type.Optional(${T}, false))`\n          : `Type.Mapped(${C}, ${K} => Type.Optional(${T}))`\n      ) : `Type.Mapped(${C}, ${K} => ${T})`\n    )\n  }\n  function* MethodSignature(node: ts.MethodSignature): IterableIterator<string> {\n    const parameters = node.parameters\n      .map((parameter) =>\n        parameter.dotDotDotToken !== undefined ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter),\n      )\n      .join(', ');\n    const returnType = node.type === undefined ? `Type.Unknown()` : Collect(node.type);\n    yield `${node.name.getText()}: Type.Function([${parameters}], ${returnType})`;\n  }\n  // prettier-ignore\n  function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {\n    const collect = node.getChildren().map(node => Collect(node)).join('')\n    yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])` // can't remove trailing here\n  }\n  // prettier-ignore\n  function* TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {\n    const collect = node.getChildren().map(node => Collect(node)).join(', ')\n    if (collect.length > 0) yield `${collect}`\n  }\n  function* TemplateHead(node: ts.TemplateHead) {\n    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;\n  }\n  function* TemplateMiddle(node: ts.TemplateMiddle) {\n    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;\n  }\n  function* TemplateTail(node: ts.TemplateTail) {\n    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `;\n  }\n  function* ThisTypeNode(node: ts.ThisTypeNode) {\n    yield `This`;\n  }\n  function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {\n    const types = node.types.map((type) => Collect(type)).join(',\\n');\n    yield `Type.Intersect([\\n${types}\\n])`;\n  }\n  function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {\n    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {\n      const type = Collect(node.type);\n      yield `Type.KeyOf(${type})`;\n    }\n    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {\n      yield `Type.Readonly(${Collect(node.type)})`;\n    }\n  }\n  function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {\n    yield Collect(node.type);\n  }\n  function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {\n    const parameters = node.parameters\n      .map((parameter) =>\n        parameter.dotDotDotToken !== undefined ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter),\n      )\n      .join(', ');\n    const returns = Collect(node.type);\n    yield `Type.Function([${parameters}], ${returns})`;\n  }\n  function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {\n    const parameters = node.parameters.map((param) => Collect(param)).join(', ');\n    const returns = Collect(node.type);\n    yield `Type.Constructor([${parameters}], ${returns})`;\n  }\n  function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {\n    useImports = true;\n    const exports = IsExport(node) ? 'export ' : '';\n    const members = node.members.map((member) => member.getText()).join(', ');\n    const enumType = `${exports}enum Enum${node.name.getText()} { ${members} }`;\n    const staticType = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;\n    const type = `${exports}const ${node.name.getText()} = Type.Enum(Enum${node.name.getText()})`;\n    yield [enumType, '', staticType, type].join('\\n');\n  }\n  function PropertiesFromTypeElementArray(members: ts.NodeArray<ts.TypeElement>): string {\n    const properties = members.filter((member) => !ts.isIndexSignatureDeclaration(member));\n    const indexers = members.filter((member) => ts.isIndexSignatureDeclaration(member));\n    const propertyCollect = properties.map((property) => Collect(property)).join(',\\n');\n    const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : '';\n    if (properties.length === 0 && indexer.length > 0) {\n      return `{},\\n{\\nadditionalProperties: ${indexer}\\n }`;\n    } else if (properties.length > 0 && indexer.length > 0) {\n      return `{\\n${propertyCollect}\\n},\\n{\\nadditionalProperties: ${indexer}\\n }`;\n    } else {\n      return `{\\n${propertyCollect}\\n}`;\n    }\n  }\n  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {\n    const members = PropertiesFromTypeElementArray(node.members);\n    yield* `Type.Object(${members})`;\n  }\n  function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {\n    useImports = true;\n    const isRecursiveType = IsRecursiveType(node);\n    if (isRecursiveType) recursiveDeclaration = node;\n    const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => Collect(node)) : [];\n    if (node.typeParameters) {\n      useGenerics = true;\n      const exports = IsExport(node) ? 'export ' : '';\n      const identifier = ResolveIdentifier(node);\n      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };\n      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ');\n      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ');\n      const members = PropertiesFromTypeElementArray(node.members);\n      // const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')\n      // const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`\n      const rawTypeExpression = IsRecursiveType(node)\n        ? `Type.Recursive(This => Type.Object(${members}))`\n        : `Type.Object(${members})`;\n      const typeExpression =\n        heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(', ')}, ${rawTypeExpression}])`;\n      const type = InjectOptions(typeExpression, options);\n      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`;\n      yield `${typeDeclaration}`;\n    } else {\n      const exports = IsExport(node) ? 'export ' : '';\n      const identifier = ResolveIdentifier(node);\n      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };\n      const members = PropertiesFromTypeElementArray(node.members);\n      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;\n      const rawTypeExpression = IsRecursiveType(node)\n        ? `Type.Recursive(This => Type.Object(${members}))`\n        : `Type.Object(${members})`;\n      const typeExpression =\n        heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(', ')}, ${rawTypeExpression}])`;\n      const type = InjectOptions(typeExpression, options);\n      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`;\n      yield `${staticDeclaration}\\n${typeDeclaration}`;\n    }\n    recursiveDeclaration = null;\n  }\n  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {\n    useImports = true;\n    const isRecursiveType = IsRecursiveType(node);\n    if (isRecursiveType) recursiveDeclaration = node;\n    // Generics case\n    if (node.typeParameters) {\n      useGenerics = true;\n      const exports = IsExport(node) ? 'export ' : '';\n      const options = useIdentifiers ? { $id: ResolveIdentifier(node) } : {};\n      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ');\n      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ');\n      const type_0 = Collect(node.type);\n      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;\n      const type_2 = InjectOptions(type_1, options);\n      // const names = node.typeParameters.map((param) => Collect(param)).join(', ')\n      // const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`\n      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type_2}`;\n      yield `${typeDeclaration}`;\n    } else {\n      const exports = IsExport(node) ? 'export ' : '';\n      const options = useIdentifiers\n        ? { $id: ResolveIdentifier(node), ...ResolveOptions(node) }\n        : { ...ResolveOptions(node) };\n      const type_0 = Collect(node.type);\n      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;\n      const type_2 = InjectOptions(type_1, options);\n      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;\n      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type_2}`;\n      yield `${staticDeclaration}\\n${typeDeclaration}`;\n    }\n    recursiveDeclaration = null;\n  }\n  function* HeritageClause(node: ts.HeritageClause): IterableIterator<string> {\n    // Consideration: This may be better expressed as a heritage type (for review)\n    const types = node.types.map((node) => Collect(node));\n    if (types.length === 1) return yield types[0];\n    // yield `Type.Composite([${types.join(', ')}])`\n\n    // Note: Heritage clauses are only used in extends cases, and where Composite\n    // is the exterior type. These types will be prepended to the Composite array.\n    yield types.join(', ');\n  }\n  function* IndexedAccessType(node: ts.IndexedAccessTypeNode): IterableIterator<string> {\n    const obj = node.objectType.getText();\n    const key = Collect(node.indexType);\n    yield `Type.Index(${obj}, ${key})`;\n  }\n  function* ExpressionWithTypeArguments(node: ts.ExpressionWithTypeArguments): IterableIterator<string> {\n    const name = Collect(node.expression);\n    const typeArguments = node.typeArguments === undefined ? [] : node.typeArguments.map((node) => Collect(node));\n    // todo: default type argument (resolve `= number` from `type Foo<T = number>`)\n    return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(', ')})`;\n  }\n  function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {\n    yield node.name.getText();\n  }\n  function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {\n    yield Collect(node.type);\n  }\n  function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {\n    yield `...Type.Rest(${node.type.getText()})`;\n  }\n  function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {\n    const checkType = Collect(node.checkType);\n    const extendsType = Collect(node.extendsType);\n    const trueType = Collect(node.trueType);\n    const falseType = Collect(node.falseType);\n    yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`;\n  }\n  function* isIndexSignatureDeclaration(node: ts.IndexSignatureDeclaration) {\n    // note: we ignore the key and just return the type. this is a mismatch between\n    // object and record types. Address in TypeBox by unifying validation paths\n    // for objects and record types.\n    yield Collect(node.type);\n  }\n  function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {\n    const name = node.typeName.getText();\n    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : '';\n    // --------------------------------------------------------------\n    // Instance Types\n    // --------------------------------------------------------------\n    if (name === 'Date') return yield `Type.Date()`;\n    if (name === 'Uint8Array') return yield `Type.Uint8Array()`;\n    if (name === 'String') return yield `Type.String()`;\n    if (name === 'Number') return yield `Type.Number()`;\n    if (name === 'Boolean') return yield `Type.Boolean()`;\n    if (name === 'Function') return yield `Type.Function([], Type.Unknown())`;\n    // --------------------------------------------------------------\n    // Types\n    // --------------------------------------------------------------\n    if (name === 'Array') return yield `Type.Array${args}`;\n    if (name === 'Record') return yield `Type.Record${args}`;\n    if (name === 'Partial') return yield `Type.Partial${args}`;\n    if (name === 'Required') return yield `Type.Required${args}`;\n    if (name === 'Omit') return yield `Type.Omit${args}`;\n    if (name === 'Pick') return yield `Type.Pick${args}`;\n    if (name === 'Promise') return yield `Type.Promise${args}`;\n    if (name === 'ReturnType') return yield `Type.ReturnType${args}`;\n    if (name === 'InstanceType') return yield `Type.InstanceType${args}`;\n    if (name === 'Parameters') return yield `Type.Parameters${args}`;\n    if (name === 'AsyncIterableIterator') return yield `Type.AsyncIterator${args}`;\n    if (name === 'IterableIterator') return yield `Type.Iterator${args}`;\n    if (name === 'ConstructorParameters') return yield `Type.ConstructorParameters${args}`;\n    if (name === 'Exclude') return yield `Type.Exclude${args}`;\n    if (name === 'Extract') return yield `Type.Extract${args}`;\n    if (name === 'Awaited') return yield `Type.Awaited${args}`;\n    if (name === 'Uppercase') return yield `Type.Uppercase${args}`;\n    if (name === 'Lowercase') return yield `Type.Lowercase${args}`;\n    if (name === 'Capitalize') return yield `Type.Capitalize${args}`;\n    if (name === 'Uncapitalize') return yield `Type.Uncapitalize${args}`;\n    if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) return yield `This`;\n    if (FindTypeName(node.getSourceFile(), name) && args.length === 0 /** non-resolvable */) {\n      return yield `${name}${args}`;\n    }\n    if (name in globalThis) return yield `Type.Never()`;\n    return yield `${name}${args}`;\n  }\n  function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {\n    const text = node.getText();\n    if (text === 'null') return yield `Type.Null()`;\n    yield InjectOptions(`Type.Literal(${node.getText()})`, ResolveOptions(node));\n  }\n  function* ModuleDeclaration(node: ts.ModuleDeclaration): IterableIterator<string> {\n    const export_specifier = IsExport(node) ? 'export ' : '';\n    const module_specifier = IsNamespace(node) ? 'namespace' : 'module';\n    yield `${export_specifier}${module_specifier} ${node.name.getText()} {`;\n    yield* Visit(node.body);\n    yield `}`;\n  }\n  function* ModuleBlock(node: ts.ModuleBlock): IterableIterator<string> {\n    for (const statement of node.statements) {\n      yield* Visit(statement);\n    }\n  }\n  function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {\n    // ignore\n  }\n  function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {\n    // ignore\n  }\n  function Collect(node: ts.Node | undefined): string {\n    return `${[...Visit(node)].join('')}`;\n  }\n  function* Visit(node: ts.Node | undefined): IterableIterator<string> {\n    if (node === undefined) return;\n    if (ts.isArrayTypeNode(node)) return yield* ArrayTypeNode(node);\n    if (ts.isBlock(node)) return yield* Block(node);\n    if (ts.isClassDeclaration(node)) return yield* ClassDeclaration(node);\n    if (ts.isConditionalTypeNode(node)) return yield* ConditionalTypeNode(node);\n    if (ts.isConstructorTypeNode(node)) return yield* ConstructorTypeNode(node);\n    if (ts.isEnumDeclaration(node)) return yield* EnumDeclaration(node);\n    if (ts.isExpressionWithTypeArguments(node)) return yield* ExpressionWithTypeArguments(node);\n    if (ts.isFunctionDeclaration(node)) return yield* FunctionDeclaration(node);\n    if (ts.isFunctionTypeNode(node)) return yield* FunctionTypeNode(node);\n    if (ts.isHeritageClause(node)) return yield* HeritageClause(node);\n    if (ts.isIndexedAccessTypeNode(node)) return yield* IndexedAccessType(node);\n    if (ts.isIndexSignatureDeclaration(node)) return yield* isIndexSignatureDeclaration(node);\n    if (ts.isInterfaceDeclaration(node)) return yield* InterfaceDeclaration(node);\n    if (ts.isLiteralTypeNode(node)) return yield* LiteralTypeNode(node);\n    if (ts.isPropertySignature(node)) return yield* PropertySignature(node);\n    if (ts.isModuleDeclaration(node)) return yield* ModuleDeclaration(node);\n    if (ts.isIdentifier(node)) return yield node.getText();\n    if (ts.isIntersectionTypeNode(node)) return yield* IntersectionTypeNode(node);\n    if (ts.isUnionTypeNode(node)) return yield* UnionTypeNode(node);\n    if (ts.isMappedTypeNode(node)) return yield* MappedTypeNode(node);\n    if (ts.isMethodSignature(node)) return yield* MethodSignature(node);\n    if (ts.isModuleBlock(node)) return yield* ModuleBlock(node);\n    if (ts.isParameter(node)) return yield* Parameter(node);\n    if (ts.isParenthesizedTypeNode(node)) return yield* ParenthesizedTypeNode(node);\n    if (ts.isRestTypeNode(node)) return yield* RestTypeNode(node);\n    if (ts.isTupleTypeNode(node)) return yield* TupleTypeNode(node);\n    if (ts.isTemplateLiteralTypeNode(node)) return yield* TemplateLiteralTypeNode(node);\n    if (ts.isTemplateLiteralTypeSpan(node)) return yield* TemplateLiteralTypeSpan(node);\n    if (ts.isTemplateHead(node)) return yield* TemplateHead(node);\n    if (ts.isTemplateMiddle(node)) return yield* TemplateMiddle(node);\n    if (ts.isTemplateTail(node)) return yield* TemplateTail(node);\n    if (ts.isThisTypeNode(node)) return yield* ThisTypeNode(node);\n    if (ts.isTypeAliasDeclaration(node)) return yield* TypeAliasDeclaration(node);\n    if (ts.isTypeLiteralNode(node)) return yield* TypeLiteralNode(node);\n    if (ts.isTypeOperatorNode(node)) return yield* TypeOperatorNode(node);\n    if (ts.isTypeParameterDeclaration(node)) return yield* TypeParameterDeclaration(node);\n    if (ts.isTypeReferenceNode(node)) return yield* TypeReferenceNode(node);\n    if (ts.isSourceFile(node)) return yield* SourceFile(node);\n    if (node.kind === ts.SyntaxKind.ExportKeyword) return yield `export`;\n    if (node.kind === ts.SyntaxKind.KeyOfKeyword) return yield `Type.KeyOf()`;\n    if (node.kind === ts.SyntaxKind.NumberKeyword) return yield `Type.Number()`;\n    if (node.kind === ts.SyntaxKind.BigIntKeyword) return yield `Type.BigInt()`;\n    if (node.kind === ts.SyntaxKind.StringKeyword) return yield `Type.String()`;\n    if (node.kind === ts.SyntaxKind.SymbolKeyword) return yield `Type.Symbol()`;\n    if (node.kind === ts.SyntaxKind.BooleanKeyword) return yield `Type.Boolean()`;\n    if (node.kind === ts.SyntaxKind.UndefinedKeyword) return yield `Type.Undefined()`;\n    if (node.kind === ts.SyntaxKind.UnknownKeyword) return yield `Type.Unknown()`;\n    if (node.kind === ts.SyntaxKind.AnyKeyword) return yield `Type.Any()`;\n    if (node.kind === ts.SyntaxKind.NeverKeyword) return yield `Type.Never()`;\n    if (node.kind === ts.SyntaxKind.NullKeyword) return yield `Type.Null()`;\n    if (node.kind === ts.SyntaxKind.VoidKeyword) return yield `Type.Void()`;\n    if (node.kind === ts.SyntaxKind.EndOfFileToken) return;\n    if (node.kind === ts.SyntaxKind.SyntaxList) {\n      for (const child of node.getChildren()) {\n        yield* Visit(child);\n      }\n      return;\n    }\n    console.warn('Unhandled:', ts.SyntaxKind[node.kind], node.getText());\n  }\n  function ImportStatement(): string {\n    if (!(useImports && useTypeBoxImport)) return '';\n    const set = new Set<string>(['Type', 'Static']);\n    if (useGenerics) {\n      set.add('TSchema');\n    }\n    if (useOptions) {\n      set.add('SchemaOptions');\n    }\n    if (useCloneType) {\n      set.add('CloneType');\n    }\n    const imports = [...set].join(', ');\n    return `import { ${imports} } from '@sinclair/typebox'`;\n  }\n  /** Generates TypeBox types from TypeScript interface and type definitions */\n  export function Generate(typescriptCode: string, options?: TypeScriptToTypeBoxOptions) {\n    useExportsEverything = options?.useExportEverything ?? false;\n    useIdentifiers = options?.useIdentifiers ?? false;\n    useTypeBoxImport = options?.useTypeBoxImport ?? true;\n    typenames.clear();\n    useImports = false;\n    useOptions = false;\n    useGenerics = false;\n    useCloneType = false;\n    blockLevel = 0;\n    const source = ts.createSourceFile('types.ts', typescriptCode, ts.ScriptTarget.ESNext, true);\n    const declarations = [...Visit(source)].join('\\n\\n');\n    const imports = ImportStatement();\n    const typescript = [imports, '', '', declarations].join('\\n');\n    const assertion = ts.transpileModule(typescript, transpilerOptions);\n    if (assertion.diagnostics && assertion.diagnostics.length > 0) {\n      throw new TypeScriptToTypeBoxError(assertion.diagnostics);\n    }\n    return typescript;\n  }\n}\n"],"names":["ts","JsDoc","TypeScriptToTypeBoxError","Error","constructor","diagnostics","TypeScriptToTypeBox","transpilerOptions","compilerOptions","strict","target","ScriptTarget","ES2022","typenames","Set","recursiveDeclaration","blockLevel","useImports","useOptions","useGenerics","useCloneType","useExportsEverything","useIdentifiers","useTypeBoxImport","FindRecursiveParent","decl","node","isTypeReferenceNode","name","getText","typeName","getChildren","some","FindRecursiveThis","isThisTypeNode","FindTypeName","found","has","isInterfaceDeclaration","isTypeAliasDeclaration","add","IsRecursiveType","check1","type","members","check2","IsReadonlyProperty","modifiers","undefined","find","modifier","IsOptionalProperty","questionToken","IsExport","IsNamespace","flags","NodeFlags","Namespace","ResolveJsDocComment","content","getFullText","trim","kind","SyntaxKind","LiteralType","startsWith","slice","lastIndexOf","replace","indices","indexOf","map","n","Infinity","i","length","ResolveOptions","Parse","ResolveIdentifier","resolve","parent","isModuleDeclaration","join","UnwrapModifier","InjectOptions","options","globalThis","Object","keys","encoded","JSON","stringify","SourceFile","next","Visit","PropertySignature","readonly","optional","type_0","Collect","type_1","ArrayTypeNode","elementType","Block","statments","statements","statement","TupleTypeNode","types","elements","UnionTypeNode","MappedTypeNode","K","typeParameter","T","C","constraint","readonlyToken","readonly_subtractive","isMinusToken","optional_subtractive","MethodSignature","parameters","parameter","dotDotDotToken","returnType","TemplateLiteralTypeNode","collect","TemplateLiteralTypeSpan","TemplateHead","text","TemplateMiddle","TemplateTail","ThisTypeNode","IntersectionTypeNode","TypeOperatorNode","operator","KeyOfKeyword","ReadonlyKeyword","Parameter","FunctionTypeNode","returns","ConstructorTypeNode","param","EnumDeclaration","exports","member","enumType","staticType","PropertiesFromTypeElementArray","properties","filter","isIndexSignatureDeclaration","indexers","propertyCollect","property","indexer","TypeLiteralNode","InterfaceDeclaration","isRecursiveType","heritage","heritageClauses","flatMap","typeParameters","identifier","$id","constraints","rawTypeExpression","typeExpression","typeDeclaration","staticDeclaration","TypeAliasDeclaration","type_2","HeritageClause","IndexedAccessType","obj","objectType","key","indexType","ExpressionWithTypeArguments","expression","typeArguments","TypeParameterDeclaration","ParenthesizedTypeNode","RestTypeNode","ConditionalTypeNode","checkType","extendsType","trueType","falseType","TypeReferenceNode","args","getSourceFile","LiteralTypeNode","ModuleDeclaration","export_specifier","module_specifier","body","ModuleBlock","FunctionDeclaration","ClassDeclaration","isArrayTypeNode","isBlock","isClassDeclaration","isConditionalTypeNode","isConstructorTypeNode","isEnumDeclaration","isExpressionWithTypeArguments","isFunctionDeclaration","isFunctionTypeNode","isHeritageClause","isIndexedAccessTypeNode","isLiteralTypeNode","isPropertySignature","isIdentifier","isIntersectionTypeNode","isUnionTypeNode","isMappedTypeNode","isMethodSignature","isModuleBlock","isParameter","isParenthesizedTypeNode","isRestTypeNode","isTupleTypeNode","isTemplateLiteralTypeNode","isTemplateLiteralTypeSpan","isTemplateHead","isTemplateMiddle","isTemplateTail","isTypeLiteralNode","isTypeOperatorNode","isTypeParameterDeclaration","isSourceFile","ExportKeyword","NumberKeyword","BigIntKeyword","StringKeyword","SymbolKeyword","BooleanKeyword","UndefinedKeyword","UnknownKeyword","AnyKeyword","NeverKeyword","NullKeyword","VoidKeyword","EndOfFileToken","SyntaxList","child","console","warn","ImportStatement","set","imports","Generate","typescriptCode","useExportEverything","clear","source","createSourceFile","ESNext","declarations","typescript","assertion","transpileModule"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;2EAwB2E,GAC3E,YAAYA,QAAQ,aAAa;AACjC,SAASC,KAAK,QAAQ,kBAAkB;AAExC,OAAO,MAAMC,iCAAiCC;;IAC5CC,YAAY,AAAgBC,WAA4B,CAAE;QACxD,KAAK,CAAC;aADoBA,cAAAA;IAE5B;AACF;;UA0BiBC;IACf,+GAA+G;IAC/G,oBAAoB;IACpB,+GAA+G;IAC/G,MAAMC,oBAAyC;QAC7CC,iBAAiB;YACfC,QAAQ;YACRC,QAAQV,GAAGW,YAAY,CAACC,MAAM;QAChC;IACF;IACA,+GAA+G;IAC/G,mBAAmB;IACnB,+GAA+G;IAC/G,4CAA4C;IAC5C,MAAMC,YAAY,IAAIC;IACtB,gFAAgF;IAChF,IAAIC,uBAAiF;IACrF,gHAAgH;IAChH,IAAIC,aAAqB;IACzB,yDAAyD;IACzD,IAAIC,aAAa;IACjB,kDAAkD;IAClD,IAAIC,aAAa;IACjB,yDAAyD;IACzD,IAAIC,cAAc;IAClB,iEAAiE;IACjE,IAAIC,eAAe;IACnB,oDAAoD;IACpD,IAAIC,uBAAuB;IAC3B,8BAA8B;IAC9B,IAAIC,iBAAiB;IACrB,2DAA2D;IAC3D,IAAIC,mBAAmB;IACvB,+GAA+G;IAC/G,YAAY;IACZ,+GAA+G;IAC/G,SAASC,oBAAoBC,IAAuD,EAAEC,IAAa;QACjG,OACE,AAAC1B,GAAG2B,mBAAmB,CAACD,SAASD,KAAKG,IAAI,CAACC,OAAO,OAAOH,KAAKI,QAAQ,CAACD,OAAO,MAC9EH,KAAKK,WAAW,GAAGC,IAAI,CAAC,CAACN,OAASF,oBAAoBC,MAAMC;IAEhE;IACA,SAASO,kBAAkBP,IAAa;QACtC,OAAOA,KAAKK,WAAW,GAAGC,IAAI,CAAC,CAACN,OAAS1B,GAAGkC,cAAc,CAACR,SAASO,kBAAkBP;IACxF;IACA,SAASS,aAAaT,IAAa,EAAEE,IAAY;QAC/C,MAAMQ,QACJvB,UAAUwB,GAAG,CAACT,SACdF,KAAKK,WAAW,GAAGC,IAAI,CAAC,CAACN;YACvB,OACE,AAAE1B,CAAAA,GAAGsC,sBAAsB,CAACZ,SAAS1B,GAAGuC,sBAAsB,CAACb,KAAI,KAAMA,KAAKE,IAAI,CAACC,OAAO,OAAOD,QACjGO,aAAaT,MAAME;QAEvB;QACF,IAAIQ,OAAOvB,UAAU2B,GAAG,CAACZ;QACzB,OAAOQ;IACT;IACA,SAASK,gBAAgBhB,IAAuD;QAC9E,MAAMiB,SAAS1C,GAAGuC,sBAAsB,CAACd,QACrC;YAACA,KAAKkB,IAAI;SAAC,CAACX,IAAI,CAAC,CAACN,OAASF,oBAAoBC,MAAMC,SACrDD,KAAKmB,OAAO,CAACZ,IAAI,CAAC,CAACN,OAASF,oBAAoBC,MAAMC;QAC1D,MAAMmB,SAAS7C,GAAGsC,sBAAsB,CAACb,SAASQ,kBAAkBR;QACpE,OAAOiB,UAAUG;IACnB;IACA,SAASC,mBAAmBpB,IAA0B;QACpD,OACEA,KAAKqB,SAAS,KAAKC,aAAatB,KAAKqB,SAAS,CAACE,IAAI,CAAC,CAACC,WAAaA,SAASrB,OAAO,OAAO,gBAAgBmB;IAE7G;IACA,SAASG,mBAAmBzB,IAA0B;QACpD,OAAOA,KAAK0B,aAAa,KAAKJ;IAChC;IACA,SAASK,SACP3B,IAAmG;QAEnG,OACEV,eAAe,KACdK,CAAAA,wBACEK,KAAKqB,SAAS,KAAKC,aAClBtB,KAAKqB,SAAS,CAACE,IAAI,CAAC,CAACC,WAAaA,SAASrB,OAAO,OAAO,cAAcmB,SAAS;IAExF;IACA,SAASM,YAAY5B,IAA0B;QAC7C,OAAOA,KAAK6B,KAAK,KAAKvD,GAAGwD,SAAS,CAACC,SAAS;IAC9C;IACA,+GAA+G;IAC/G,UAAU;IACV,+GAA+G;IAC/G,SAASC,oBACPhC,IAAmG;QAEnG,MAAMiC,UAAUjC,KAAKkC,WAAW,GAAGC,IAAI;QACvC,IAAInC,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACC,WAAW,EAAE;YAC3C,IAAIL,QAAQM,UAAU,CAAC,QAAQ;gBAC7B,6CAA6C;gBAC7C,OAAON,QAAQO,KAAK,CAAC,GAAGP,QAAQQ,WAAW,CAAC,QAAQ,GAAGC,OAAO,CAAC,UAAU;YAC3E,OAAO;gBACL,OAAO;YACT;QACF;QACA,MAAMC,UAAU;YAACV,QAAQW,OAAO,CAAC;YAAQX,QAAQW,OAAO,CAAC;YAASX,QAAQW,OAAO,CAAC;SAAa,CAACC,GAAG,CAAC,CAACC,IACnGA,MAAM,CAAC,IAAIC,WAAWD;QAExB,IAAIH,OAAO,CAAC,EAAE,KAAK,CAAC,KAAKA,OAAO,CAAC,EAAE,GAAGA,OAAO,CAAC,EAAE,IAAIA,OAAO,CAAC,EAAE,GAAGA,OAAO,CAAC,EAAE,EAAE,OAAO,IAAI,2CAA2C;QACnI,IAAK,IAAIK,IAAIL,OAAO,CAAC,EAAE,EAAEK,IAAIf,QAAQgB,MAAM,EAAED,IAAK;YAChD,IAAIf,OAAO,CAACe,EAAE,KAAK,OAAOf,OAAO,CAACe,IAAI,EAAE,KAAK,KAAK,OAAOf,QAAQO,KAAK,CAAC,GAAGQ,IAAI;QAChF;QACA,OAAO;IACT;IACA,SAASE,eACPlD,IAAmG;QAEnG,MAAMiC,UAAUD,oBAAoBhC;QACpC,OAAOzB,MAAM4E,KAAK,CAAClB;IACrB;IACA,+GAA+G;IAC/G,cAAc;IACd,+GAA+G;IAC/G,SAASmB,kBAAkBpD,IAAuD;QAChF,UAAUqD,QAAQrD,IAAa;YAC7B,IAAIA,KAAKsD,MAAM,EAAE,OAAOD,QAAQrD,KAAKsD,MAAM;YAC3C,IAAIhF,GAAGiF,mBAAmB,CAACvD,OAAO,MAAMA,KAAKE,IAAI,CAACC,OAAO;QAC3D;QACA,OAAO;eAAIkD,QAAQrD;YAAOA,KAAKE,IAAI,CAACC,OAAO;SAAG,CAACqD,IAAI,CAAC;IACtD;IACA,SAASC,eAAexC,IAAY;QAClC,IAAK,IAAI+B,IAAI,GAAGA,IAAI/B,KAAKgC,MAAM,EAAED,IAAK,IAAI/B,IAAI,CAAC+B,EAAE,KAAK,KAAK,OAAO/B,KAAKuB,KAAK,CAACQ,IAAI,GAAG/B,KAAKgC,MAAM,GAAG;QAClG,OAAOhC;IACT;IACA,sGAAsG;IACtG,sGAAsG;IACtG,qGAAqG;IACrG,kGAAkG;IAClG,yFAAyF;IACzF,kBAAkB;IAClB,SAASyC,cAAczC,IAAY,EAAE0C,OAAgC;QACnE,IAAIC,WAAWC,MAAM,CAACC,IAAI,CAACH,SAASV,MAAM,KAAK,GAAG,OAAOhC;QACzD,uBAAuB;QACvB,IAAIA,KAAK2B,OAAO,CAAC,6BAA6B,GAAG,OAAO,CAAC,uBAAuB,EAAEc,cAAcD,eAAexC,OAAO0C,SAAS,EAAE,CAAC;QAClI,IAAI1C,KAAK2B,OAAO,CAAC,qBAAqB,GAAG,OAAO,CAAC,eAAe,EAAEc,cAAcD,eAAexC,OAAO0C,SAAS,EAAE,CAAC;QAClH,IAAI1C,KAAK2B,OAAO,CAAC,qBAAqB,GAAG,OAAO,CAAC,eAAe,EAAEc,cAAcD,eAAexC,OAAO0C,SAAS,EAAE,CAAC;QAClH,MAAMI,UAAUC,KAAKC,SAAS,CAACN;QAC/B,eAAe;QACf,IAAI1C,KAAKwB,WAAW,CAAC,SAASxB,KAAKgC,MAAM,GAAG,GAAGvD,eAAe;QAC9D,IAAIuB,KAAKwB,WAAW,CAAC,SAASxB,KAAKgC,MAAM,GAAG,GAAG,OAAO,CAAC,UAAU,EAAEhC,KAAK,EAAE,EAAE8C,QAAQ,CAAC,CAAC;QACtF,kBAAkB;QAClB,IAAI9C,KAAK2B,OAAO,CAAC,SAAS,CAAC,GAAG;YAAElD,eAAe;YAAM,OAAO,CAAC,UAAU,EAAEuB,KAAK,EAAE,EAAE8C,QAAQ,CAAC,CAAC;QAAC;QAC7F,IAAI9C,KAAKwB,WAAW,CAAC,UAAUxB,KAAKgC,MAAM,GAAG,GAAG,OAAOhC,KAAKuB,KAAK,CAAC,GAAGvB,KAAKgC,MAAM,GAAG,KAAK,CAAC,EAAEc,QAAQ,CAAC,CAAC;QACrG,IAAI9C,KAAKwB,WAAW,CAAC,UAAUxB,KAAKgC,MAAM,GAAG,GAAG,OAAOhC,KAAKuB,KAAK,CAAC,GAAGvB,KAAKgC,MAAM,GAAG,KAAK,CAAC,EAAE,EAAEc,QAAQ,CAAC,CAAC;QACvG,IAAI9C,KAAKwB,WAAW,CAAC,UAAUxB,KAAKgC,MAAM,GAAG,GAAG,OAAOhC,KAAKuB,KAAK,CAAC,GAAGvB,KAAKgC,MAAM,GAAG,KAAK,CAAC,EAAE,EAAEc,QAAQ,CAAC,CAAC;QACvG,IAAI9C,KAAKwB,WAAW,CAAC,SAASxB,KAAKgC,MAAM,GAAG,GAAG,OAAOhC,KAAKuB,KAAK,CAAC,GAAGvB,KAAKgC,MAAM,GAAG,KAAK,CAAC,EAAE,EAAEc,QAAQ,CAAC,CAAC;QACtG,OAAO9C;IACT;IACA,+GAA+G;IAC/G,QAAQ;IACR,+GAA+G;IAC/G,UAAUiD,WAAWlE,IAAmB;QACtC,KAAK,MAAMmE,QAAQnE,KAAKK,WAAW,GAAI;YACrC,OAAO+D,MAAMD;QACf;IACF;IACA,UAAUE,kBAAkBrE,IAA0B;QACpD,MAAM,CAACsE,UAAUC,SAAS,GAAG;YAACnD,mBAAmBpB;YAAOyB,mBAAmBzB;SAAM;QACjF,MAAM2D,UAAUT,eAAelD;QAC/B,MAAMwE,SAASC,QAAQzE,KAAKiB,IAAI;QAChC,MAAMyD,SAAShB,cAAcc,QAAQb;QACrC,IAAIW,YAAYC,UAAU;YACxB,OAAO,MAAM,CAAC,EAAEvE,KAAKE,IAAI,CAACC,OAAO,GAAG,wBAAwB,EAAEuE,OAAO,CAAC,CAAC;QACzE,OAAO,IAAIJ,UAAU;YACnB,OAAO,MAAM,CAAC,EAAEtE,KAAKE,IAAI,CAACC,OAAO,GAAG,gBAAgB,EAAEuE,OAAO,CAAC,CAAC;QACjE,OAAO,IAAIH,UAAU;YACnB,OAAO,MAAM,CAAC,EAAEvE,KAAKE,IAAI,CAACC,OAAO,GAAG,gBAAgB,EAAEuE,OAAO,CAAC,CAAC;QACjE,OAAO;YACL,OAAO,MAAM,CAAC,EAAE1E,KAAKE,IAAI,CAACC,OAAO,GAAG,EAAE,EAAEuE,OAAO,CAAC;QAClD;IACF;IACA,UAAUC,cAAc3E,IAAsB;QAC5C,MAAMiB,OAAOwD,QAAQzE,KAAK4E,WAAW;QACrC,MAAM,CAAC,WAAW,EAAE3D,KAAK,CAAC,CAAC;IAC7B;IACA,UAAU4D,MAAM7E,IAAc;QAC5BV,cAAc;QACd,MAAMwF,YAAY9E,KAAK+E,UAAU,CAAClC,GAAG,CAAC,CAACmC,YAAcP,QAAQO,YAAYxB,IAAI,CAAC;QAC9ElE,cAAc;QACd,MAAM,CAAC,GAAG,EAAEwF,UAAU,GAAG,CAAC;IAC5B;IACA,UAAUG,cAAcjF,IAAsB;QAC5C,MAAMkF,QAAQlF,KAAKmF,QAAQ,CAACtC,GAAG,CAAC,CAAC5B,OAASwD,QAAQxD,OAAOuC,IAAI,CAAC;QAC9D,MAAM,CAAC,cAAc,EAAE0B,MAAM,IAAI,CAAC;IACpC;IACA,UAAUE,cAAcpF,IAAsB;QAC5C,MAAMkF,QAAQlF,KAAKkF,KAAK,CAACrC,GAAG,CAAC,CAAC5B,OAASwD,QAAQxD,OAAOuC,IAAI,CAAC;QAC3D,MAAM,CAAC,cAAc,EAAE0B,MAAM,IAAI,CAAC;IACpC;IACA,UAAUG,eAAerF,IAAuB;QAC9C,MAAMsF,IAAIb,QAAQzE,KAAKuF,aAAa;QACpC,MAAMC,IAAIf,QAAQzE,KAAKiB,IAAI;QAC3B,MAAMwE,IAAIhB,QAAQzE,KAAKuF,aAAa,CAACG,UAAU;QAC/C,MAAMpB,WAAWtE,KAAK2F,aAAa,KAAKrE;QACxC,MAAMiD,WAAWvE,KAAK0B,aAAa,KAAKJ;QACxC,MAAMsE,uBAAuBtB,YAAYhG,GAAGuH,YAAY,CAAC7F,KAAK2F,aAAa;QAC3E,MAAMG,uBAAuBvB,YAAYjG,GAAGuH,YAAY,CAAC7F,KAAK0B,aAAa;QAC3E,kBAAkB;QAClB,OAAO,MACL,AAAC4C,YAAYC,WACX,AAACqB,wBAAwBE,uBAAwB,CAAC,YAAY,EAAEL,EAAE,EAAE,EAAEH,EAAE,gCAAgC,EAAEE,EAAE,iBAAiB,CAAC,GAC9H,AAACI,uBAAwB,CAAC,YAAY,EAAEH,EAAE,EAAE,EAAEH,EAAE,gCAAgC,EAAEE,EAAE,UAAU,CAAC,GAC/F,AAACM,uBAAwB,CAAC,YAAY,EAAEL,EAAE,EAAE,EAAEH,EAAE,gCAAgC,EAAEE,EAAE,UAAU,CAAC,GAC/F,CAAC,YAAY,EAAEC,EAAE,EAAE,EAAEH,EAAE,gCAAgC,EAAEE,EAAE,GAAG,CAAC,GAC7D,AAAClB,WACHsB,uBACI,CAAC,YAAY,EAAEH,EAAE,EAAE,EAAEH,EAAE,kBAAkB,EAAEE,EAAE,SAAS,CAAC,GACvD,CAAC,YAAY,EAAEC,EAAE,EAAE,EAAEH,EAAE,kBAAkB,EAAEE,EAAE,EAAE,CAAC,GAClD,AAACjB,WACHuB,uBACI,CAAC,YAAY,EAAEL,EAAE,EAAE,EAAEH,EAAE,kBAAkB,EAAEE,EAAE,SAAS,CAAC,GACvD,CAAC,YAAY,EAAEC,EAAE,EAAE,EAAEH,EAAE,kBAAkB,EAAEE,EAAE,EAAE,CAAC,GAClD,CAAC,YAAY,EAAEC,EAAE,EAAE,EAAEH,EAAE,IAAI,EAAEE,EAAE,CAAC,CAAC;IAEzC;IACA,UAAUO,gBAAgB/F,IAAwB;QAChD,MAAMgG,aAAahG,KAAKgG,UAAU,CAC/BnD,GAAG,CAAC,CAACoD,YACJA,UAAUC,cAAc,KAAK5E,YAAY,CAAC,aAAa,EAAEmD,QAAQwB,WAAW,CAAC,CAAC,GAAGxB,QAAQwB,YAE1FzC,IAAI,CAAC;QACR,MAAM2C,aAAanG,KAAKiB,IAAI,KAAKK,YAAY,CAAC,cAAc,CAAC,GAAGmD,QAAQzE,KAAKiB,IAAI;QACjF,MAAM,CAAC,EAAEjB,KAAKE,IAAI,CAACC,OAAO,GAAG,iBAAiB,EAAE6F,WAAW,GAAG,EAAEG,WAAW,CAAC,CAAC;IAC/E;IACA,kBAAkB;IAClB,UAAUC,wBAAwBpG,IAAgC;QAChE,MAAMqG,UAAUrG,KAAKK,WAAW,GAAGwC,GAAG,CAAC7C,CAAAA,OAAQyE,QAAQzE,OAAOwD,IAAI,CAAC;QACnE,MAAM,CAAC,sBAAsB,EAAE6C,QAAQ7D,KAAK,CAAC,GAAG6D,QAAQpD,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,6BAA6B;;IACvG;IACA,kBAAkB;IAClB,UAAUqD,wBAAwBtG,IAAgC;QAChE,MAAMqG,UAAUrG,KAAKK,WAAW,GAAGwC,GAAG,CAAC7C,CAAAA,OAAQyE,QAAQzE,OAAOwD,IAAI,CAAC;QACnE,IAAI6C,QAAQpD,MAAM,GAAG,GAAG,MAAM,CAAC,EAAEoD,QAAQ,CAAC;IAC5C;IACA,UAAUE,aAAavG,IAAqB;QAC1C,IAAIA,KAAKwG,IAAI,CAACvD,MAAM,GAAG,GAAG,MAAM,CAAC,cAAc,EAAEjD,KAAKwG,IAAI,CAAC,IAAI,CAAC;IAClE;IACA,UAAUC,eAAezG,IAAuB;QAC9C,IAAIA,KAAKwG,IAAI,CAACvD,MAAM,GAAG,GAAG,MAAM,CAAC,cAAc,EAAEjD,KAAKwG,IAAI,CAAC,IAAI,CAAC;IAClE;IACA,UAAUE,aAAa1G,IAAqB;QAC1C,IAAIA,KAAKwG,IAAI,CAACvD,MAAM,GAAG,GAAG,MAAM,CAAC,cAAc,EAAEjD,KAAKwG,IAAI,CAAC,IAAI,CAAC;IAClE;IACA,UAAUG,aAAa3G,IAAqB;QAC1C,MAAM,CAAC,IAAI,CAAC;IACd;IACA,UAAU4G,qBAAqB5G,IAA6B;QAC1D,MAAMkF,QAAQlF,KAAKkF,KAAK,CAACrC,GAAG,CAAC,CAAC5B,OAASwD,QAAQxD,OAAOuC,IAAI,CAAC;QAC3D,MAAM,CAAC,kBAAkB,EAAE0B,MAAM,IAAI,CAAC;IACxC;IACA,UAAU2B,iBAAiB7G,IAAyB;QAClD,IAAIA,KAAK8G,QAAQ,KAAKxI,GAAG+D,UAAU,CAAC0E,YAAY,EAAE;YAChD,MAAM9F,OAAOwD,QAAQzE,KAAKiB,IAAI;YAC9B,MAAM,CAAC,WAAW,EAAEA,KAAK,CAAC,CAAC;QAC7B;QACA,IAAIjB,KAAK8G,QAAQ,KAAKxI,GAAG+D,UAAU,CAAC2E,eAAe,EAAE;YACnD,MAAM,CAAC,cAAc,EAAEvC,QAAQzE,KAAKiB,IAAI,EAAE,CAAC,CAAC;QAC9C;IACF;IACA,UAAUgG,UAAUjH,IAA6B;QAC/C,MAAMyE,QAAQzE,KAAKiB,IAAI;IACzB;IACA,UAAUiG,iBAAiBlH,IAAyB;QAClD,MAAMgG,aAAahG,KAAKgG,UAAU,CAC/BnD,GAAG,CAAC,CAACoD,YACJA,UAAUC,cAAc,KAAK5E,YAAY,CAAC,aAAa,EAAEmD,QAAQwB,WAAW,CAAC,CAAC,GAAGxB,QAAQwB,YAE1FzC,IAAI,CAAC;QACR,MAAM2D,UAAU1C,QAAQzE,KAAKiB,IAAI;QACjC,MAAM,CAAC,eAAe,EAAE+E,WAAW,GAAG,EAAEmB,QAAQ,CAAC,CAAC;IACpD;IACA,UAAUC,oBAAoBpH,IAA4B;QACxD,MAAMgG,aAAahG,KAAKgG,UAAU,CAACnD,GAAG,CAAC,CAACwE,QAAU5C,QAAQ4C,QAAQ7D,IAAI,CAAC;QACvE,MAAM2D,UAAU1C,QAAQzE,KAAKiB,IAAI;QACjC,MAAM,CAAC,kBAAkB,EAAE+E,WAAW,GAAG,EAAEmB,QAAQ,CAAC,CAAC;IACvD;IACA,UAAUG,gBAAgBtH,IAAwB;QAChDT,aAAa;QACb,MAAMgI,UAAU5F,SAAS3B,QAAQ,YAAY;QAC7C,MAAMkB,UAAUlB,KAAKkB,OAAO,CAAC2B,GAAG,CAAC,CAAC2E,SAAWA,OAAOrH,OAAO,IAAIqD,IAAI,CAAC;QACpE,MAAMiE,WAAW,CAAC,EAAEF,QAAQ,SAAS,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,GAAG,EAAEe,QAAQ,EAAE,CAAC;QAC3E,MAAMwG,aAAa,CAAC,EAAEH,QAAQ,KAAK,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,iBAAiB,EAAEH,KAAKE,IAAI,CAACC,OAAO,GAAG,CAAC,CAAC;QAClG,MAAMc,OAAO,CAAC,EAAEsG,QAAQ,MAAM,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,iBAAiB,EAAEH,KAAKE,IAAI,CAACC,OAAO,GAAG,CAAC,CAAC;QAC7F,MAAM;YAACsH;YAAU;YAAIC;YAAYzG;SAAK,CAACuC,IAAI,CAAC;IAC9C;IACA,SAASmE,+BAA+BzG,OAAqC;QAC3E,MAAM0G,aAAa1G,QAAQ2G,MAAM,CAAC,CAACL,SAAW,CAAClJ,GAAGwJ,2BAA2B,CAACN;QAC9E,MAAMO,WAAW7G,QAAQ2G,MAAM,CAAC,CAACL,SAAWlJ,GAAGwJ,2BAA2B,CAACN;QAC3E,MAAMQ,kBAAkBJ,WAAW/E,GAAG,CAAC,CAACoF,WAAaxD,QAAQwD,WAAWzE,IAAI,CAAC;QAC7E,MAAM0E,UAAUH,SAAS9E,MAAM,GAAG,IAAIwB,QAAQsD,QAAQ,CAACA,SAAS9E,MAAM,GAAG,EAAE,IAAI;QAC/E,IAAI2E,WAAW3E,MAAM,KAAK,KAAKiF,QAAQjF,MAAM,GAAG,GAAG;YACjD,OAAO,CAAC,8BAA8B,EAAEiF,QAAQ,IAAI,CAAC;QACvD,OAAO,IAAIN,WAAW3E,MAAM,GAAG,KAAKiF,QAAQjF,MAAM,GAAG,GAAG;YACtD,OAAO,CAAC,GAAG,EAAE+E,gBAAgB,+BAA+B,EAAEE,QAAQ,IAAI,CAAC;QAC7E,OAAO;YACL,OAAO,CAAC,GAAG,EAAEF,gBAAgB,GAAG,CAAC;QACnC;IACF;IACA,UAAUG,gBAAgBnI,IAAwB;QAChD,MAAMkB,UAAUyG,+BAA+B3H,KAAKkB,OAAO;QAC3D,OAAO,CAAC,YAAY,EAAEA,QAAQ,CAAC,CAAC;IAClC;IACA,UAAUkH,qBAAqBpI,IAA6B;QAC1DT,aAAa;QACb,MAAM8I,kBAAkBtH,gBAAgBf;QACxC,IAAIqI,iBAAiBhJ,uBAAuBW;QAC5C,MAAMsI,WAAWtI,KAAKuI,eAAe,KAAKjH,YAAYtB,KAAKuI,eAAe,CAACC,OAAO,CAAC,CAACxI,OAASyE,QAAQzE,SAAS,EAAE;QAChH,IAAIA,KAAKyI,cAAc,EAAE;YACvBhJ,cAAc;YACd,MAAM8H,UAAU5F,SAAS3B,QAAQ,YAAY;YAC7C,MAAM0I,aAAatF,kBAAkBpD;YACrC,MAAM2D,UAAU/D,iBAAiB;gBAAE,GAAGsD,eAAelD,KAAK;gBAAE2I,KAAKD;YAAW,IAAI;gBAAE,GAAGxF,eAAelD,KAAK;YAAC;YAC1G,MAAM4I,cAAc5I,KAAKyI,cAAc,CAAC5F,GAAG,CAAC,CAACwE,QAAU,CAAC,EAAE5C,QAAQ4C,OAAO,gBAAgB,CAAC,EAAE7D,IAAI,CAAC;YACjG,MAAMwC,aAAahG,KAAKyI,cAAc,CAAC5F,GAAG,CAAC,CAACwE,QAAU,CAAC,EAAE5C,QAAQ4C,OAAO,EAAE,EAAE5C,QAAQ4C,OAAO,CAAC,EAAE7D,IAAI,CAAC;YACnG,MAAMtC,UAAUyG,+BAA+B3H,KAAKkB,OAAO;YAC3D,mFAAmF;YACnF,kJAAkJ;YAClJ,MAAM2H,oBAAoB9H,gBAAgBf,QACtC,CAAC,mCAAmC,EAAEkB,QAAQ,EAAE,CAAC,GACjD,CAAC,YAAY,EAAEA,QAAQ,CAAC,CAAC;YAC7B,MAAM4H,iBACJR,SAASrF,MAAM,KAAK,IAAI4F,oBAAoB,CAAC,gBAAgB,EAAEP,SAAS9E,IAAI,CAAC,MAAM,EAAE,EAAEqF,kBAAkB,EAAE,CAAC;YAC9G,MAAM5H,OAAOyC,cAAcoF,gBAAgBnF;YAC3C,MAAMoF,kBAAkB,CAAC,EAAExB,QAAQ,MAAM,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,IAAI,EAAEyI,YAAY,EAAE,EAAE5C,WAAW,KAAK,EAAE/E,KAAK,CAAC;YAC7G,MAAM,CAAC,EAAE8H,gBAAgB,CAAC;QAC5B,OAAO;YACL,MAAMxB,UAAU5F,SAAS3B,QAAQ,YAAY;YAC7C,MAAM0I,aAAatF,kBAAkBpD;YACrC,MAAM2D,UAAU/D,iBAAiB;gBAAE,GAAGsD,eAAelD,KAAK;gBAAE2I,KAAKD;YAAW,IAAI;gBAAE,GAAGxF,eAAelD,KAAK;YAAC;YAC1G,MAAMkB,UAAUyG,+BAA+B3H,KAAKkB,OAAO;YAC3D,MAAM8H,oBAAoB,CAAC,EAAEzB,QAAQ,KAAK,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,iBAAiB,EAAEH,KAAKE,IAAI,CAACC,OAAO,GAAG,CAAC,CAAC;YACzG,MAAM0I,oBAAoB9H,gBAAgBf,QACtC,CAAC,mCAAmC,EAAEkB,QAAQ,EAAE,CAAC,GACjD,CAAC,YAAY,EAAEA,QAAQ,CAAC,CAAC;YAC7B,MAAM4H,iBACJR,SAASrF,MAAM,KAAK,IAAI4F,oBAAoB,CAAC,gBAAgB,EAAEP,SAAS9E,IAAI,CAAC,MAAM,EAAE,EAAEqF,kBAAkB,EAAE,CAAC;YAC9G,MAAM5H,OAAOyC,cAAcoF,gBAAgBnF;YAC3C,MAAMoF,kBAAkB,CAAC,EAAExB,QAAQ,MAAM,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,GAAG,EAAEc,KAAK,CAAC;YAC1E,MAAM,CAAC,EAAE+H,kBAAkB,EAAE,EAAED,gBAAgB,CAAC;QAClD;QACA1J,uBAAuB;IACzB;IACA,UAAU4J,qBAAqBjJ,IAA6B;QAC1DT,aAAa;QACb,MAAM8I,kBAAkBtH,gBAAgBf;QACxC,IAAIqI,iBAAiBhJ,uBAAuBW;QAC5C,gBAAgB;QAChB,IAAIA,KAAKyI,cAAc,EAAE;YACvBhJ,cAAc;YACd,MAAM8H,UAAU5F,SAAS3B,QAAQ,YAAY;YAC7C,MAAM2D,UAAU/D,iBAAiB;gBAAE+I,KAAKvF,kBAAkBpD;YAAM,IAAI,CAAC;YACrE,MAAM4I,cAAc5I,KAAKyI,cAAc,CAAC5F,GAAG,CAAC,CAACwE,QAAU,CAAC,EAAE5C,QAAQ4C,OAAO,gBAAgB,CAAC,EAAE7D,IAAI,CAAC;YACjG,MAAMwC,aAAahG,KAAKyI,cAAc,CAAC5F,GAAG,CAAC,CAACwE,QAAU,CAAC,EAAE5C,QAAQ4C,OAAO,EAAE,EAAE5C,QAAQ4C,OAAO,CAAC,EAAE7D,IAAI,CAAC;YACnG,MAAMgB,SAASC,QAAQzE,KAAKiB,IAAI;YAChC,MAAMyD,SAAS2D,kBAAkB,CAAC,uBAAuB,EAAE7D,OAAO,CAAC,CAAC,GAAGA;YACvE,MAAM0E,SAASxF,cAAcgB,QAAQf;YACrC,8EAA8E;YAC9E,kJAAkJ;YAClJ,MAAMoF,kBAAkB,CAAC,EAAExB,QAAQ,MAAM,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,IAAI,EAAEyI,YAAY,EAAE,EAAE5C,WAAW,KAAK,EAAEkD,OAAO,CAAC;YAC/G,MAAM,CAAC,EAAEH,gBAAgB,CAAC;QAC5B,OAAO;YACL,MAAMxB,UAAU5F,SAAS3B,QAAQ,YAAY;YAC7C,MAAM2D,UAAU/D,iBACZ;gBAAE+I,KAAKvF,kBAAkBpD;gBAAO,GAAGkD,eAAelD,KAAK;YAAC,IACxD;gBAAE,GAAGkD,eAAelD,KAAK;YAAC;YAC9B,MAAMwE,SAASC,QAAQzE,KAAKiB,IAAI;YAChC,MAAMyD,SAAS2D,kBAAkB,CAAC,uBAAuB,EAAE7D,OAAO,CAAC,CAAC,GAAGA;YACvE,MAAM0E,SAASxF,cAAcgB,QAAQf;YACrC,MAAMqF,oBAAoB,CAAC,EAAEzB,QAAQ,KAAK,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,iBAAiB,EAAEH,KAAKE,IAAI,CAACC,OAAO,GAAG,CAAC,CAAC;YACzG,MAAM4I,kBAAkB,CAAC,EAAExB,QAAQ,MAAM,EAAEvH,KAAKE,IAAI,CAACC,OAAO,GAAG,GAAG,EAAE+I,OAAO,CAAC;YAC5E,MAAM,CAAC,EAAEF,kBAAkB,EAAE,EAAED,gBAAgB,CAAC;QAClD;QACA1J,uBAAuB;IACzB;IACA,UAAU8J,eAAenJ,IAAuB;QAC9C,8EAA8E;QAC9E,MAAMkF,QAAQlF,KAAKkF,KAAK,CAACrC,GAAG,CAAC,CAAC7C,OAASyE,QAAQzE;QAC/C,IAAIkF,MAAMjC,MAAM,KAAK,GAAG,OAAO,MAAMiC,KAAK,CAAC,EAAE;QAC7C,gDAAgD;QAEhD,6EAA6E;QAC7E,8EAA8E;QAC9E,MAAMA,MAAM1B,IAAI,CAAC;IACnB;IACA,UAAU4F,kBAAkBpJ,IAA8B;QACxD,MAAMqJ,MAAMrJ,KAAKsJ,UAAU,CAACnJ,OAAO;QACnC,MAAMoJ,MAAM9E,QAAQzE,KAAKwJ,SAAS;QAClC,MAAM,CAAC,WAAW,EAAEH,IAAI,EAAE,EAAEE,IAAI,CAAC,CAAC;IACpC;IACA,UAAUE,4BAA4BzJ,IAAoC;QACxE,MAAME,OAAOuE,QAAQzE,KAAK0J,UAAU;QACpC,MAAMC,gBAAgB3J,KAAK2J,aAAa,KAAKrI,YAAY,EAAE,GAAGtB,KAAK2J,aAAa,CAAC9G,GAAG,CAAC,CAAC7C,OAASyE,QAAQzE;QACvG,+EAA+E;QAC/E,OAAO,MAAM2J,cAAc1G,MAAM,KAAK,IAAI,CAAC,EAAE/C,KAAK,CAAC,GAAG,CAAC,EAAEA,KAAK,CAAC,EAAEyJ,cAAcnG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9F;IACA,UAAUoG,yBAAyB5J,IAAiC;QAClE,MAAMA,KAAKE,IAAI,CAACC,OAAO;IACzB;IACA,UAAU0J,sBAAsB7J,IAA8B;QAC5D,MAAMyE,QAAQzE,KAAKiB,IAAI;IACzB;IACA,UAAU6I,aAAa9J,IAAqB;QAC1C,MAAM,CAAC,aAAa,EAAEA,KAAKiB,IAAI,CAACd,OAAO,GAAG,CAAC,CAAC;IAC9C;IACA,UAAU4J,oBAAoB/J,IAA4B;QACxD,MAAMgK,YAAYvF,QAAQzE,KAAKgK,SAAS;QACxC,MAAMC,cAAcxF,QAAQzE,KAAKiK,WAAW;QAC5C,MAAMC,WAAWzF,QAAQzE,KAAKkK,QAAQ;QACtC,MAAMC,YAAY1F,QAAQzE,KAAKmK,SAAS;QACxC,MAAM,CAAC,aAAa,EAAEH,UAAU,EAAE,EAAEC,YAAY,EAAE,EAAEC,SAAS,EAAE,EAAEC,UAAU,CAAC,CAAC;IAC/E;IACA,UAAUrC,4BAA4B9H,IAAkC;QACtE,+EAA+E;QAC/E,2EAA2E;QAC3E,gCAAgC;QAChC,MAAMyE,QAAQzE,KAAKiB,IAAI;IACzB;IACA,UAAUmJ,kBAAkBpK,IAA0B;QACpD,MAAME,OAAOF,KAAKI,QAAQ,CAACD,OAAO;QAClC,MAAMkK,OAAOrK,KAAK2J,aAAa,GAAG,CAAC,CAAC,EAAE3J,KAAK2J,aAAa,CAAC9G,GAAG,CAAC,CAAC5B,OAASwD,QAAQxD,OAAOuC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG;QACtG,iEAAiE;QACjE,iBAAiB;QACjB,iEAAiE;QACjE,IAAItD,SAAS,QAAQ,OAAO,MAAM,CAAC,WAAW,CAAC;QAC/C,IAAIA,SAAS,cAAc,OAAO,MAAM,CAAC,iBAAiB,CAAC;QAC3D,IAAIA,SAAS,UAAU,OAAO,MAAM,CAAC,aAAa,CAAC;QACnD,IAAIA,SAAS,UAAU,OAAO,MAAM,CAAC,aAAa,CAAC;QACnD,IAAIA,SAAS,WAAW,OAAO,MAAM,CAAC,cAAc,CAAC;QACrD,IAAIA,SAAS,YAAY,OAAO,MAAM,CAAC,iCAAiC,CAAC;QACzE,iEAAiE;QACjE,QAAQ;QACR,iEAAiE;QACjE,IAAIA,SAAS,SAAS,OAAO,MAAM,CAAC,UAAU,EAAEmK,KAAK,CAAC;QACtD,IAAInK,SAAS,UAAU,OAAO,MAAM,CAAC,WAAW,EAAEmK,KAAK,CAAC;QACxD,IAAInK,SAAS,WAAW,OAAO,MAAM,CAAC,YAAY,EAAEmK,KAAK,CAAC;QAC1D,IAAInK,SAAS,YAAY,OAAO,MAAM,CAAC,aAAa,EAAEmK,KAAK,CAAC;QAC5D,IAAInK,SAAS,QAAQ,OAAO,MAAM,CAAC,SAAS,EAAEmK,KAAK,CAAC;QACpD,IAAInK,SAAS,QAAQ,OAAO,MAAM,CAAC,SAAS,EAAEmK,KAAK,CAAC;QACpD,IAAInK,SAAS,WAAW,OAAO,MAAM,CAAC,YAAY,EAAEmK,KAAK,CAAC;QAC1D,IAAInK,SAAS,cAAc,OAAO,MAAM,CAAC,eAAe,EAAEmK,KAAK,CAAC;QAChE,IAAInK,SAAS,gBAAgB,OAAO,MAAM,CAAC,iBAAiB,EAAEmK,KAAK,CAAC;QACpE,IAAInK,SAAS,cAAc,OAAO,MAAM,CAAC,eAAe,EAAEmK,KAAK,CAAC;QAChE,IAAInK,SAAS,yBAAyB,OAAO,MAAM,CAAC,kBAAkB,EAAEmK,KAAK,CAAC;QAC9E,IAAInK,SAAS,oBAAoB,OAAO,MAAM,CAAC,aAAa,EAAEmK,KAAK,CAAC;QACpE,IAAInK,SAAS,yBAAyB,OAAO,MAAM,CAAC,0BAA0B,EAAEmK,KAAK,CAAC;QACtF,IAAInK,SAAS,WAAW,OAAO,MAAM,CAAC,YAAY,EAAEmK,KAAK,CAAC;QAC1D,IAAInK,SAAS,WAAW,OAAO,MAAM,CAAC,YAAY,EAAEmK,KAAK,CAAC;QAC1D,IAAInK,SAAS,WAAW,OAAO,MAAM,CAAC,YAAY,EAAEmK,KAAK,CAAC;QAC1D,IAAInK,SAAS,aAAa,OAAO,MAAM,CAAC,cAAc,EAAEmK,KAAK,CAAC;QAC9D,IAAInK,SAAS,aAAa,OAAO,MAAM,CAAC,cAAc,EAAEmK,KAAK,CAAC;QAC9D,IAAInK,SAAS,cAAc,OAAO,MAAM,CAAC,eAAe,EAAEmK,KAAK,CAAC;QAChE,IAAInK,SAAS,gBAAgB,OAAO,MAAM,CAAC,iBAAiB,EAAEmK,KAAK,CAAC;QACpE,IAAIhL,yBAAyB,QAAQS,oBAAoBT,sBAAsBW,OAAO,OAAO,MAAM,CAAC,IAAI,CAAC;QACzG,IAAIS,aAAaT,KAAKsK,aAAa,IAAIpK,SAASmK,KAAKpH,MAAM,KAAK,EAAE,mBAAmB,KAAI;YACvF,OAAO,MAAM,CAAC,EAAE/C,KAAK,EAAEmK,KAAK,CAAC;QAC/B;QACA,IAAInK,QAAQ0D,YAAY,OAAO,MAAM,CAAC,YAAY,CAAC;QACnD,OAAO,MAAM,CAAC,EAAE1D,KAAK,EAAEmK,KAAK,CAAC;IAC/B;IACA,UAAUE,gBAAgBvK,IAAwB;QAChD,MAAMwG,OAAOxG,KAAKG,OAAO;QACzB,IAAIqG,SAAS,QAAQ,OAAO,MAAM,CAAC,WAAW,CAAC;QAC/C,MAAM9C,cAAc,CAAC,aAAa,EAAE1D,KAAKG,OAAO,GAAG,CAAC,CAAC,EAAE+C,eAAelD;IACxE;IACA,UAAUwK,kBAAkBxK,IAA0B;QACpD,MAAMyK,mBAAmB9I,SAAS3B,QAAQ,YAAY;QACtD,MAAM0K,mBAAmB9I,YAAY5B,QAAQ,cAAc;QAC3D,MAAM,CAAC,EAAEyK,iBAAiB,EAAEC,iBAAiB,CAAC,EAAE1K,KAAKE,IAAI,CAACC,OAAO,GAAG,EAAE,CAAC;QACvE,OAAOiE,MAAMpE,KAAK2K,IAAI;QACtB,MAAM,CAAC,CAAC,CAAC;IACX;IACA,UAAUC,YAAY5K,IAAoB;QACxC,KAAK,MAAMgF,aAAahF,KAAK+E,UAAU,CAAE;YACvC,OAAOX,MAAMY;QACf;IACF;IACA,UAAU6F,oBAAoB7K,IAA4B;IACxD,SAAS;IACX;IACA,UAAU8K,iBAAiB9K,IAAyB;IAClD,SAAS;IACX;IACA,SAASyE,QAAQzE,IAAyB;QACxC,OAAO,CAAC,EAAE;eAAIoE,MAAMpE;SAAM,CAACwD,IAAI,CAAC,IAAI,CAAC;IACvC;IACA,UAAUY,MAAMpE,IAAyB;QACvC,IAAIA,SAASsB,WAAW;QACxB,IAAIhD,GAAGyM,eAAe,CAAC/K,OAAO,OAAO,OAAO2E,cAAc3E;QAC1D,IAAI1B,GAAG0M,OAAO,CAAChL,OAAO,OAAO,OAAO6E,MAAM7E;QAC1C,IAAI1B,GAAG2M,kBAAkB,CAACjL,OAAO,OAAO,OAAO8K,iBAAiB9K;QAChE,IAAI1B,GAAG4M,qBAAqB,CAAClL,OAAO,OAAO,OAAO+J,oBAAoB/J;QACtE,IAAI1B,GAAG6M,qBAAqB,CAACnL,OAAO,OAAO,OAAOoH,oBAAoBpH;QACtE,IAAI1B,GAAG8M,iBAAiB,CAACpL,OAAO,OAAO,OAAOsH,gBAAgBtH;QAC9D,IAAI1B,GAAG+M,6BAA6B,CAACrL,OAAO,OAAO,OAAOyJ,4BAA4BzJ;QACtF,IAAI1B,GAAGgN,qBAAqB,CAACtL,OAAO,OAAO,OAAO6K,oBAAoB7K;QACtE,IAAI1B,GAAGiN,kBAAkB,CAACvL,OAAO,OAAO,OAAOkH,iBAAiBlH;QAChE,IAAI1B,GAAGkN,gBAAgB,CAACxL,OAAO,OAAO,OAAOmJ,eAAenJ;QAC5D,IAAI1B,GAAGmN,uBAAuB,CAACzL,OAAO,OAAO,OAAOoJ,kBAAkBpJ;QACtE,IAAI1B,GAAGwJ,2BAA2B,CAAC9H,OAAO,OAAO,OAAO8H,4BAA4B9H;QACpF,IAAI1B,GAAGsC,sBAAsB,CAACZ,OAAO,OAAO,OAAOoI,qBAAqBpI;QACxE,IAAI1B,GAAGoN,iBAAiB,CAAC1L,OAAO,OAAO,OAAOuK,gBAAgBvK;QAC9D,IAAI1B,GAAGqN,mBAAmB,CAAC3L,OAAO,OAAO,OAAOqE,kBAAkBrE;QAClE,IAAI1B,GAAGiF,mBAAmB,CAACvD,OAAO,OAAO,OAAOwK,kBAAkBxK;QAClE,IAAI1B,GAAGsN,YAAY,CAAC5L,OAAO,OAAO,MAAMA,KAAKG,OAAO;QACpD,IAAI7B,GAAGuN,sBAAsB,CAAC7L,OAAO,OAAO,OAAO4G,qBAAqB5G;QACxE,IAAI1B,GAAGwN,eAAe,CAAC9L,OAAO,OAAO,OAAOoF,cAAcpF;QAC1D,IAAI1B,GAAGyN,gBAAgB,CAAC/L,OAAO,OAAO,OAAOqF,eAAerF;QAC5D,IAAI1B,GAAG0N,iBAAiB,CAAChM,OAAO,OAAO,OAAO+F,gBAAgB/F;QAC9D,IAAI1B,GAAG2N,aAAa,CAACjM,OAAO,OAAO,OAAO4K,YAAY5K;QACtD,IAAI1B,GAAG4N,WAAW,CAAClM,OAAO,OAAO,OAAOiH,UAAUjH;QAClD,IAAI1B,GAAG6N,uBAAuB,CAACnM,OAAO,OAAO,OAAO6J,sBAAsB7J;QAC1E,IAAI1B,GAAG8N,cAAc,CAACpM,OAAO,OAAO,OAAO8J,aAAa9J;QACxD,IAAI1B,GAAG+N,eAAe,CAACrM,OAAO,OAAO,OAAOiF,cAAcjF;QAC1D,IAAI1B,GAAGgO,yBAAyB,CAACtM,OAAO,OAAO,OAAOoG,wBAAwBpG;QAC9E,IAAI1B,GAAGiO,yBAAyB,CAACvM,OAAO,OAAO,OAAOsG,wBAAwBtG;QAC9E,IAAI1B,GAAGkO,cAAc,CAACxM,OAAO,OAAO,OAAOuG,aAAavG;QACxD,IAAI1B,GAAGmO,gBAAgB,CAACzM,OAAO,OAAO,OAAOyG,eAAezG;QAC5D,IAAI1B,GAAGoO,cAAc,CAAC1M,OAAO,OAAO,OAAO0G,aAAa1G;QACxD,IAAI1B,GAAGkC,cAAc,CAACR,OAAO,OAAO,OAAO2G,aAAa3G;QACxD,IAAI1B,GAAGuC,sBAAsB,CAACb,OAAO,OAAO,OAAOiJ,qBAAqBjJ;QACxE,IAAI1B,GAAGqO,iBAAiB,CAAC3M,OAAO,OAAO,OAAOmI,gBAAgBnI;QAC9D,IAAI1B,GAAGsO,kBAAkB,CAAC5M,OAAO,OAAO,OAAO6G,iBAAiB7G;QAChE,IAAI1B,GAAGuO,0BAA0B,CAAC7M,OAAO,OAAO,OAAO4J,yBAAyB5J;QAChF,IAAI1B,GAAG2B,mBAAmB,CAACD,OAAO,OAAO,OAAOoK,kBAAkBpK;QAClE,IAAI1B,GAAGwO,YAAY,CAAC9M,OAAO,OAAO,OAAOkE,WAAWlE;QACpD,IAAIA,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC0K,aAAa,EAAE,OAAO,MAAM,CAAC,MAAM,CAAC;QACpE,IAAI/M,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC0E,YAAY,EAAE,OAAO,MAAM,CAAC,YAAY,CAAC;QACzE,IAAI/G,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC2K,aAAa,EAAE,OAAO,MAAM,CAAC,aAAa,CAAC;QAC3E,IAAIhN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC4K,aAAa,EAAE,OAAO,MAAM,CAAC,aAAa,CAAC;QAC3E,IAAIjN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC6K,aAAa,EAAE,OAAO,MAAM,CAAC,aAAa,CAAC;QAC3E,IAAIlN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC8K,aAAa,EAAE,OAAO,MAAM,CAAC,aAAa,CAAC;QAC3E,IAAInN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAAC+K,cAAc,EAAE,OAAO,MAAM,CAAC,cAAc,CAAC;QAC7E,IAAIpN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACgL,gBAAgB,EAAE,OAAO,MAAM,CAAC,gBAAgB,CAAC;QACjF,IAAIrN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACiL,cAAc,EAAE,OAAO,MAAM,CAAC,cAAc,CAAC;QAC7E,IAAItN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACkL,UAAU,EAAE,OAAO,MAAM,CAAC,UAAU,CAAC;QACrE,IAAIvN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACmL,YAAY,EAAE,OAAO,MAAM,CAAC,YAAY,CAAC;QACzE,IAAIxN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACoL,WAAW,EAAE,OAAO,MAAM,CAAC,WAAW,CAAC;QACvE,IAAIzN,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACqL,WAAW,EAAE,OAAO,MAAM,CAAC,WAAW,CAAC;QACvE,IAAI1N,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACsL,cAAc,EAAE;QAChD,IAAI3N,KAAKoC,IAAI,KAAK9D,GAAG+D,UAAU,CAACuL,UAAU,EAAE;YAC1C,KAAK,MAAMC,SAAS7N,KAAKK,WAAW,GAAI;gBACtC,OAAO+D,MAAMyJ;YACf;YACA;QACF;QACAC,QAAQC,IAAI,CAAC,cAAczP,GAAG+D,UAAU,CAACrC,KAAKoC,IAAI,CAAC,EAAEpC,KAAKG,OAAO;IACnE;IACA,SAAS6N;QACP,IAAI,CAAEzO,CAAAA,cAAcM,gBAAe,GAAI,OAAO;QAC9C,MAAMoO,MAAM,IAAI7O,IAAY;YAAC;YAAQ;SAAS;QAC9C,IAAIK,aAAa;YACfwO,IAAInN,GAAG,CAAC;QACV;QACA,IAAItB,YAAY;YACdyO,IAAInN,GAAG,CAAC;QACV;QACA,IAAIpB,cAAc;YAChBuO,IAAInN,GAAG,CAAC;QACV;QACA,MAAMoN,UAAU;eAAID;SAAI,CAACzK,IAAI,CAAC;QAC9B,OAAO,CAAC,SAAS,EAAE0K,QAAQ,2BAA2B,CAAC;IACzD;IAEO,SAASC,SAASC,cAAsB,EAAEzK,OAAoC;QACnFhE,uBAAuBgE,SAAS0K,uBAAuB;QACvDzO,iBAAiB+D,SAAS/D,kBAAkB;QAC5CC,mBAAmB8D,SAAS9D,oBAAoB;QAChDV,UAAUmP,KAAK;QACf/O,aAAa;QACbC,aAAa;QACbC,cAAc;QACdC,eAAe;QACfJ,aAAa;QACb,MAAMiP,SAASjQ,GAAGkQ,gBAAgB,CAAC,YAAYJ,gBAAgB9P,GAAGW,YAAY,CAACwP,MAAM,EAAE;QACvF,MAAMC,eAAe;eAAItK,MAAMmK;SAAQ,CAAC/K,IAAI,CAAC;QAC7C,MAAM0K,UAAUF;QAChB,MAAMW,aAAa;YAACT;YAAS;YAAI;YAAIQ;SAAa,CAAClL,IAAI,CAAC;QACxD,MAAMoL,YAAYtQ,GAAGuQ,eAAe,CAACF,YAAY9P;QACjD,IAAI+P,UAAUjQ,WAAW,IAAIiQ,UAAUjQ,WAAW,CAACsE,MAAM,GAAG,GAAG;YAC7D,MAAM,IAAIzE,yBAAyBoQ,UAAUjQ,WAAW;QAC1D;QACA,OAAOgQ;IACT;IApBA,2EAA2E,uBAC3DR,WAAAA;AAoBlB,GA5kBiBvP,wBAAAA"}

package/lib/schema/typebox/gen/index.js

@@ -1,3 +0,0 @@
-export * as TypeGen from './codegen/index.js';
-
-//# sourceMappingURL=index.js.map

package/lib/schema/typebox/gen/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/schema/typebox/gen/index.ts"],"sourcesContent":["export * as TypeGen from './codegen';\n"],"names":["TypeGen"],"rangeMappings":"","mappings":"AAAA,OAAO,KAAKA,OAAO,MAAM,YAAY"}

package/src/asyncs/sleep.ts

@@ -1 +0,0 @@
-export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

package/src/schema/typebox/gen/codegen/common/encoder.ts

@@ -1,99 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-// --------------------------------------------------------------------------
-// Character
-// --------------------------------------------------------------------------
-namespace Character {
-  export function DollarSign(code: number) {
-    return code === 36;
-  }
-  export function IsUnderscore(code: number) {
-    return code === 95;
-  }
-  export function IsAlpha(code: number) {
-    return (code >= 64 && code <= 90) || (code >= 97 && code <= 122);
-  }
-  export function IsNumeric(code: number) {
-    return code >= 48 && code <= 57;
-  }
-}
-// --------------------------------------------------------------------------
-// MemberExpressionEncoder
-// --------------------------------------------------------------------------
-export namespace MemberExpressionEncoder {
-  function IsFirstCharacterNumeric(value: string) {
-    if (value.length === 0) return false;
-    return Character.IsNumeric(value.charCodeAt(0));
-  }
-  function IsAccessor(value: string) {
-    if (IsFirstCharacterNumeric(value)) return false;
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i);
-      const check =
-        Character.IsAlpha(code) ||
-        Character.IsNumeric(code) ||
-        Character.DollarSign(code) ||
-        Character.IsUnderscore(code);
-      if (!check) return false;
-    }
-    return true;
-  }
-  function EscapeHyphen(key: string) {
-    return key.replace(/'/g, "\\'");
-  }
-  export function Encode(object: string, key: string) {
-    return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
-  }
-}
-// --------------------------------------------------------------------------
-// PropertyEncoder
-// --------------------------------------------------------------------------
-export namespace PropertyEncoder {
-  function IsFirstCharacterNumeric(value: string) {
-    if (value.length === 0) return false;
-    return Character.IsNumeric(value.charCodeAt(0));
-  }
-  function IsSafeProperty(value: string) {
-    if (IsFirstCharacterNumeric(value)) return false;
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i);
-      const check =
-        Character.IsAlpha(code) ||
-        Character.IsNumeric(code) ||
-        Character.DollarSign(code) ||
-        Character.IsUnderscore(code);
-      if (!check) return false;
-    }
-    return true;
-  }
-  function Quoted(value: string) {
-    return `'${value}'`;
-  }
-  export function Encode(value: string) {
-    return IsSafeProperty(value) ? value : Quoted(value);
-  }
-}

package/src/schema/typebox/gen/codegen/common/formatter.ts

@@ -1,31 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export namespace Formatter {
-  export function Format(code: string): string {
-    return code;
-  }
-}

package/src/schema/typebox/gen/codegen/common/index.ts

@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './encoder';
-export * from './formatter';
-export * from './jsdoc';

package/src/schema/typebox/gen/codegen/common/jsdoc.ts

@@ -1,93 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-/** JSDoc Property Parser */
-export namespace JsDoc {
-  // ----------------------------------------------------------------
-  // Quotes
-  // ----------------------------------------------------------------
-  function ConsumeQuote(content: string): [consumed: string, rest: string] {
-    if (!IsQuote(content)) return ['', content];
-    const quote = content[0];
-    for (let i = 1; i < content.length; i++) {
-      if (content[i] === quote) return [content.slice(1, i), content.slice(i)];
-      if (content[i] === '\n') return [content.slice(1, i), content.slice(i)];
-    }
-    return [content.slice(1), ''];
-  }
-  function IsQuote(content: string) {
-    return content[0] === '"' || content[0] === "'";
-  }
-  // ----------------------------------------------------------------
-  // Decode
-  // ----------------------------------------------------------------
-  function DecodeWithNonQuotedProperties(content: string): any {
-    const parseFunction = new Function(`return (${content});`);
-    return parseFunction();
-  }
-  function Decode(content: string) {
-    try {
-      return DecodeWithNonQuotedProperties(content);
-    } catch {
-      return content;
-    }
-  }
-  function* ParseValue(key: string, content: string): IterableIterator<[string, any]> {
-    if (IsQuote(content)) {
-      const [consumed, rest] = ConsumeQuote(content);
-      yield [key, Decode(consumed)];
-      return yield* ParseContent(rest);
-    }
-    for (let i = 0; i < content.length; i++) {
-      if (content[i] === '\n' || content[i] === '-') {
-        const value = content.slice(0, i).trim();
-        const rest = content.slice(i);
-        yield [key, Decode(value)];
-        return yield* ParseContent(rest);
-      }
-    }
-  }
-  function* ParseKey(content: string): IterableIterator<[string, any]> {
-    for (let i = 1; i < content.length; i++) {
-      if (content[i] === ' ') {
-        const key = content.slice(1, i);
-        const rest = content.slice(i).trimStart();
-        return yield* ParseValue(key, rest);
-      }
-    }
-  }
-  function* ParseContent(content: string): IterableIterator<[string, any]> {
-    for (let i = 0; i < content.length; i++) {
-      if (content[i] === '@') {
-        return yield* ParseKey(content.slice(i));
-      }
-    }
-  }
-  export function Parse(content: string): Record<string, any> {
-    const properties = [...ParseContent(content)];
-    return properties.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-  }
-}