@powerlines/deepkit 0.6.167 → 0.7.0

package/dist/vendor/type-compiler/compiler-Nkxc4PLJ.d.mts

@@ -0,0 +1,578 @@
+import { c as ReflectionConfig, i as MatchResult, l as ReflectionConfigCache, t as ConfigResolver } from "./config-D9DM7Du_.mjs";
+import ts, { ArrowFunction, Bundle, ClassDeclaration, ClassExpression, CompilerHost, CompilerOptions, ConstructorDeclaration, CustomTransformer, CustomTransformerFactory, Declaration, EntityName, ExportDeclaration, Expression, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, JSDocImportTag, MethodDeclaration, ModuleDeclaration, ModuleExportName, Node, NodeFactory, ParseConfigHost, PropertyAccessExpression, QualifiedName, ResolvedModule, ScriptKind, SourceFile, Statement, StringLiteral, Symbol as Symbol$1, SymbolTable, TransformationContext, TypeAliasDeclaration, TypeChecker, TypeParameterDeclaration, TypeReferenceNode } from "typescript";
+
+//#region ../../node_modules/.pnpm/@deepkit+type-spec@1.0.1_patch_hash=f3c3a4fd486751022d78f17d39a5a79f493bca20b185964ca1aba41fbfc93244/node_modules/@deepkit/type-spec/dist/cjs/src/type.d.ts
+/**
+ * The instruction set.
+ * Should not be greater than 93 members, because we encode it via charCode starting at 33. +93 means we end up with charCode=126
+ * (which is '~' and the last char that can be represented without \x. The next 127 is '\x7F').
+ */
+declare enum ReflectionOp {
+  never = 0,
+  any = 1,
+  unknown = 2,
+  void = 3,
+  object = 4,
+  string = 5,
+  number = 6,
+  numberBrand = 7,
+  boolean = 8,
+  bigint = 9,
+  symbol = 10,
+  null = 11,
+  undefined = 12,
+  /**
+   * The literal type of string, number, or boolean.
+   *
+   * This OP has 1 parameter. The next byte is the absolute address of the literal on the stack, which is the actual literal value.
+   *
+   * Pushes a function type.
+   */
+  literal = 13,
+  /**
+   * This OP pops all types on the current stack frame.
+   *
+   * This OP has 1 parameter. The next byte is the absolute address of a string|number|symbol entry on the stack.
+   *
+   * Pushes a function type.
+   */
+  function = 14,
+  /**
+   * This OP pops all types on the current stack frame.
+   *
+   * Pushes a method type.
+   */
+  method = 15,
+  methodSignature = 16,
+  //has 1 parameter, reference to stack for its property name
+  parameter = 17,
+  /**
+   * This OP pops the latest type entry on the stack.
+   *
+   * Pushes a property type.
+   */
+  property = 18,
+  propertySignature = 19,
+  //has 1 parameter, reference to stack for its property name
+  /**
+   * This OP pops all types on the current stack frame. Those types should be method|property.
+   *
+   * Pushes a TypeClass onto the stack.
+   */
+  class = 20,
+  /**
+   * If a class extends another class with generics, this OP represents the generic type arguments of the super class.
+   *
+   * e.g. `class A extends B<string, boolean>`, string and boolean are on the stack and classExtends pops() them, and then assigns to A.extendsTypeArguments = [string, boolean].
+   *
+   * This is only emitted when the class that is currently being described actually extends another class and uses generics.
+   *
+   * This OP has 1 argument and pops x types from the stack. X is the first argument.
+   * Expects a TypeClass on the stack.
+   */
+  classExtends = 21,
+  /**
+   * This OP has 1 parameter, the stack entry to the actual class symbol.
+   */
+  classReference = 22,
+  /**
+   * Marks the last entry in the stack as optional. Used for method|property. Equal to the QuestionMark operator in a property assignment.
+   */
+  optional = 23,
+  readonly = 24,
+  public = 25,
+  private = 26,
+  protected = 27,
+  abstract = 28,
+  defaultValue = 29,
+  description = 30,
+  rest = 31,
+  regexp = 32,
+  enum = 33,
+  enumMember = 34,
+  //has one argument, the name.
+  set = 35,
+  map = 36,
+  /**
+   * Pops the latest stack entry and uses it as T for an array type.
+   *
+   * Pushes an array type.
+   */
+  array = 37,
+  tuple = 38,
+  tupleMember = 39,
+  namedTupleMember = 40,
+  //has one argument, the name.
+  union = 41,
+  //pops frame. requires frame start when stack can be dirty.
+  intersection = 42,
+  indexSignature = 43,
+  objectLiteral = 44,
+  mappedType = 45,
+  //2 parameters: functionPointer and modifier.
+  in = 46,
+  frame = 47,
+  //creates a new stack frame
+  moveFrame = 48,
+  //pop() as T, pops the current stack frame, push(T)
+  return = 49,
+  templateLiteral = 50,
+  date = 51,
+  int8Array = 52,
+  uint8ClampedArray = 53,
+  uint8Array = 54,
+  int16Array = 55,
+  uint16Array = 56,
+  int32Array = 57,
+  uint32Array = 58,
+  float32Array = 59,
+  float64Array = 60,
+  bigInt64Array = 61,
+  arrayBuffer = 62,
+  promise = 63,
+  arg = 64,
+  //@deprecated. parameter is a number referencing an entry in the stack, relative to the beginning of the current frame, *-1. pushes that entry onto the stack. this is related to the calling convention.
+  typeParameter = 65,
+  //generic type parameter, e.g. T in a generic. has 1 parameter: reference to the name.
+  typeParameterDefault = 66,
+  //generic type parameter with a default value, e.g. T in a generic. has 1 parameter: reference to the name. pop() for the default value
+  var = 67,
+  //reserve a new variable in the stack
+  loads = 68,
+  //pushes to the stack a referenced value in the stack. has 2 parameters: <frame> <index>, frame is a negative offset to the frame, and index the index of the stack entry withing the referenced frame
+  indexAccess = 69,
+  //T['string'], 2 items on the stack
+  keyof = 70,
+  //keyof operator
+  infer = 71,
+  //2 params, like `loads`
+  typeof = 72,
+  //1 parameter that points to a function returning the runtime value from which we need to extract the type
+  condition = 73,
+  jumpCondition = 74,
+  //@deprecated. used when INFER is used in `extends` conditional branch. 2 args: left program, right program
+  jump = 75,
+  //jump to an address
+  call = 76,
+  //has one parameter, the next program address. creates a new stack frame with current program address as first stack entry, and jumps back to that + 1.
+  inline = 77,
+  inlineCall = 78,
+  distribute = 79,
+  //has one parameter, the co-routine program index.
+  extends = 80,
+  //X extends Y in a conditional type, XY popped from the stack, pushes boolean on the stack
+  widen = 81,
+  //widens the type on the stack, .e.g 'asd' => string, 34 => number, etc. this is necessary for infer runtime data, and widen if necessary (object member or non-contained literal)
+  static = 82,
+  mappedType2 = 83,
+  //same as mappedType2 but the given functionPointer returns a tuple [type, name]
+  functionReference = 84,
+  //Same as classReference but for functions
+  callSignature = 85,
+  //Same as function but for call signatures (in object literals)
+  /**
+   * Assign for Enum, Interface, Class, and TypeAlias declaration at the very end
+   * of the program the typeName. This is so that we have type names available even
+   * if the JS code is minified.
+   *
+   * his operator also assigns originTypes to the type, as it acts as the finalization
+   * step of a type.
+   */
+  typeName = 86,
+  //has one parameter, the index of the stack entry that contains the type name. Uses current head of the stack as type and assigns typeName to it.
+  /**
+   * If a class implement an interface or type,
+   *
+   * e.g. `class A implements B`, then B is on the stack and implements pops() it, and then assigns to A.implements = [B].
+   *
+   * This is only emitted when the class that is currently being described actually implements something.
+   *
+   * This OP has 1 argument and pops x types from the stack. X is the first argument.
+   * Expects a TypeClass on the stack.
+   */
+  implements = 87,
+  //pops one type from the stack and assigns it to the latest class on the stack as `implements` type.
+  nominal = 88,
+  //marks the last type on the stack as nominal. (used at the end of class/interface/type alias programs).
+  /**
+   * Custom Storm Software operators
+   */
+  tags = 89
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=439aa6e683a9a48c3ebbf3529be5811680c45c22d6a265d_be73b50bc43bac944747b8ca0498113a/node_modules/@deepkit/type-compiler/dist/cjs/src/ts-types.d.ts
+/**
+ * Contains @internal properties that are not yet in the public API of TS.
+ */
+interface SourceFile$1 extends SourceFile {
+  /**
+   * If two source files are for the same version of the same package, one will redirect to the other.
+   * (See `createRedirectSourceFile` in program.ts.)
+   * The redirect will have this set. The redirected-to source file will be in `redirectTargetsMap`.
+   */
+  redirectInfo?: any;
+  scriptKind?: ScriptKind;
+  externalModuleIndicator?: Node;
+  commonJsModuleIndicator?: Node;
+  jsGlobalAugmentations?: SymbolTable;
+  symbol?: Symbol$1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=439aa6e683a9a48c3ebbf3529be5811680c45c22d6a265d_be73b50bc43bac944747b8ca0498113a/node_modules/@deepkit/type-compiler/dist/cjs/src/reflection-ast.d.ts
+type PackExpression = Expression | string | number | boolean | bigint;
+declare class NodeConverter {
+  protected f: NodeFactory;
+  constructor(f: NodeFactory);
+  toExpression<T extends PackExpression | PackExpression[]>(node?: T): Expression;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=439aa6e683a9a48c3ebbf3529be5811680c45c22d6a265d_be73b50bc43bac944747b8ca0498113a/node_modules/@deepkit/type-compiler/dist/cjs/src/resolver.d.ts
+/**
+ * A utility to resolve a module path and its declaration.
+ *
+ * It automatically reads a SourceFile, binds and caches it.
+ */
+declare class Resolver {
+  compilerOptions: CompilerOptions;
+  host: CompilerHost;
+  protected sourceFiles: {
+    [fileName: string]: SourceFile;
+  };
+  constructor(compilerOptions: CompilerOptions, host: CompilerHost, sourceFiles: {
+    [fileName: string]: SourceFile;
+  });
+  resolve(from: SourceFile, importOrExportNode: ExportDeclaration | ImportDeclaration | JSDocImportTag): SourceFile | undefined;
+  protected resolveImpl(modulePath: StringLiteral, sourceFile: SourceFile): ResolvedModule | undefined;
+  /**
+   * Tries to resolve the .ts/d.ts file path for a given module path.
+   * Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+   *
+   * @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+   * @param modulePath the x in 'from x'.
+   */
+  resolveSourceFile(sourceFile: SourceFile, modulePath: StringLiteral): SourceFile | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=439aa6e683a9a48c3ebbf3529be5811680c45c22d6a265d_be73b50bc43bac944747b8ca0498113a/node_modules/@deepkit/type-compiler/dist/cjs/src/compiler.d.ts
+declare function encodeOps(ops: ReflectionOp[]): string;
+declare const packSizeByte: number;
+/**
+ * It can't be more ops than this given number
+ */
+declare const packSize: number;
+interface TagsReflectionStruct {
+  hidden?: boolean;
+  ignore?: boolean;
+  internal?: boolean;
+  runtime?: boolean;
+  alias?: string[];
+  title?: string;
+  permission?: string[];
+  domain?: string;
+}
+declare function debugPackStruct(sourceFile: SourceFile$1, forType: Node, pack: {
+  ops: ReflectionOp[];
+  stack: PackExpression[];
+}): void;
+interface Frame {
+  variables: {
+    name: string;
+    index: number;
+  }[];
+  opIndex: number;
+  conditional?: true;
+  previous?: Frame;
+}
+type StackEntry = Expression | string | number | boolean;
+declare class CompilerProgram {
+  forNode: Node;
+  sourceFile?: SourceFile$1 | undefined;
+  protected ops: ReflectionOp[];
+  protected stack: StackEntry[];
+  protected mainOffset: number;
+  protected stackPosition: number;
+  protected frame: Frame;
+  protected activeCoRoutines: {
+    ops: ReflectionOp[];
+  }[];
+  protected coRoutines: {
+    ops: ReflectionOp[];
+  }[];
+  constructor(forNode: Node, sourceFile?: SourceFile$1 | undefined);
+  buildPackStruct(): {
+    ops: ReflectionOp[];
+    stack: StackEntry[];
+  };
+  isEmpty(): boolean;
+  pushConditionalFrame(): void;
+  pushStack(item: StackEntry): number;
+  pushCoRoutine(): void;
+  popCoRoutine(): number;
+  pushOp(...ops: ReflectionOp[]): void;
+  pushOpAtFrame(frame: Frame, ...ops: ReflectionOp[]): void;
+  /**
+   * Returns the index of the `entry` in the stack, if already exists. If not, add it, and return that new index.
+   */
+  findOrAddStackEntry(entry: any): number;
+  /**
+   * To make room for a stack entry expected on the stack as input for example.
+   */
+  increaseStackPosition(): number;
+  protected resolveFunctionParameters: Map<ts.Node, number>;
+  resolveFunctionParametersIncrease(fn: Node): void;
+  resolveFunctionParametersDecrease(fn: Node): void;
+  isResolveFunctionParameters(fn: Node): boolean;
+  /**
+   *
+   * Each pushFrame() call needs a popFrame() call.
+   */
+  pushFrame(implicit?: boolean): Frame;
+  findConditionalFrame(): Frame | undefined;
+  /**
+   * Remove stack without doing it as OP in the processor. Some other command calls popFrame() already, which makes popFrameImplicit() an implicit popFrame.
+   * e.g. union, class, etc. all call popFrame(). the current CompilerProgram needs to be aware of that, which this function is for.
+   */
+  popFrameImplicit(): void;
+  moveFrame(): void;
+  pushVariable(name: string, frame?: Frame): number;
+  pushTemplateParameter(name: string, withDefault?: boolean): number;
+  findVariable(name: string, frame?: Frame): {
+    frameOffset: number;
+    stackIndex: number;
+  } | undefined;
+}
+declare class Cache {
+  resolver: ReflectionConfigCache;
+  sourceFiles: {
+    [fileName: string]: SourceFile$1;
+  };
+  globalSourceFiles?: SourceFile$1[];
+  /**
+   * Signals the cache to check if it needs to be cleared.
+   */
+  tick(): void;
+}
+/**
+ * Read the TypeScript AST and generate pack struct (instructions + pre-defined stack).
+ *
+ * This transformer extracts type and add the encoded (so its small and low overhead) at classes and functions as property.
+ *
+ * Deepkit/type can then extract and decode them on-demand.
+ */
+declare class ReflectionTransformer implements CustomTransformer {
+  protected context: TransformationContext;
+  protected cache: Cache;
+  sourceFile: SourceFile$1;
+  protected f: NodeFactory;
+  protected embedAssignType: boolean;
+  /**
+   * Types added to this map will get a type program directly under it.
+   * This is for types used in the very same file.
+   */
+  protected compileDeclarations: Map<ts.TypeAliasDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration, {
+    name: EntityName;
+    sourceFile: SourceFile$1;
+    compiled?: Statement[];
+  }>;
+  /**
+   * Types added to this map will get a type program at the top root level of the program.
+   * This is for imported types, which need to be inlined into the current file, as we do not emit type imports (TS will omit them).
+   */
+  protected embedDeclarations: Map<ts.Node, {
+    name: EntityName;
+    sourceFile?: SourceFile$1;
+  }>;
+  /**
+   * When a node was embedded or compiled (from the maps above), we store it here to know to not add it again.
+   */
+  protected compiledDeclarations: Set<ts.Node>;
+  protected addImports: {
+    from: Expression;
+    identifier: Identifier;
+  }[];
+  protected nodeConverter: NodeConverter;
+  protected typeChecker?: TypeChecker;
+  protected resolver: Resolver;
+  protected host: CompilerHost;
+  protected overriddenHost: boolean;
+  protected overriddenConfigResolver?: ConfigResolver;
+  protected compilerOptions: CompilerOptions;
+  /**
+   * When a deep call expression was found a script-wide variable is necessary
+   * as temporary storage.
+   */
+  protected tempResultIdentifier?: Identifier;
+  protected parseConfigHost: ParseConfigHost;
+  protected intrinsicMetaDeclaration: TypeAliasDeclaration;
+  constructor(context: TransformationContext, cache?: Cache);
+  forHost(host: CompilerHost): this;
+  withReflection(config: ReflectionConfig): this;
+  transformBundle(node: Bundle): Bundle;
+  getTempResultIdentifier(): Identifier;
+  protected getConfigResolver(sourceFile: {
+    fileName: string;
+  }): ConfigResolver;
+  protected getReflectionConfig(sourceFile: {
+    fileName: string;
+  }): MatchResult;
+  protected isWithReflection(sourceFile: SourceFile$1 | undefined, node: Node & {
+    __deepkitConfig?: ReflectionConfig;
+  }): boolean;
+  transformSourceFile(sourceFile: SourceFile$1): SourceFile$1;
+  protected getModuleType(): "cjs" | "esm";
+  protected getArrowFunctionΩPropertyAccessIdentifier(node: ArrowFunction): Identifier | undefined;
+  protected injectResetΩ<T extends FunctionDeclaration | FunctionExpression | MethodDeclaration | ConstructorDeclaration | ArrowFunction>(node: T): T;
+  protected createProgramVarFromNode(node: Node, name: EntityName, sourceFile?: SourceFile$1): Statement[];
+  protected extractPackStructOfExpression(node: Expression, program: CompilerProgram): void;
+  protected parseDefaultValue(kind: ts.SyntaxKind, defaultValue: string): any;
+  protected parseTagReflection(node: Node | Declaration | ClassDeclaration | ClassExpression): TagsReflectionStruct;
+  protected extractTagReflections(program: CompilerProgram, node?: Node): void;
+  protected extractDefaultValueReflection(program: CompilerProgram, node?: Node): void;
+  protected extractDescriptionReflection(program: CompilerProgram, node?: Node): void;
+  protected extractPackStructOfType(node: Node | Declaration | ClassDeclaration | ClassExpression, program: CompilerProgram): void;
+  protected knownClasses: {
+    [name: string]: ReflectionOp;
+  };
+  protected getGlobalLibs(): SourceFile$1[];
+  /**
+   * This is a custom resolver based on populated `locals` from the binder. It uses a custom resolution algorithm since
+   * we have no access to the binder/TypeChecker directly and instantiating a TypeChecker per file/transformer is incredible slow.
+   */
+  protected resolveDeclaration(typeName: EntityName): {
+    declaration: Node;
+    importDeclaration?: ImportDeclaration | JSDocImportTag;
+    typeOnly?: boolean;
+  } | void;
+  protected getDeclarationVariableName(typeName: EntityName): Identifier;
+  /**
+   * The semantic of isExcluded is different from checking if the fileName is part
+   * of reflection config option. isExcluded checks if the file should be excluded
+   * via the exclude option. mainly used to exclude globals and external libraries.
+   */
+  protected isExcluded(fileName: string): boolean;
+  protected extractPackStructOfTypeReference(type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+  /**
+   * Returns the class declaration, function/arrow declaration, or block where type was used.
+   */
+  protected getTypeUser(type: Node): Node;
+  /**
+   * With this function we want to check if `type` is used in the signature itself from the parent of `declaration`.
+   * If so, we do not try to infer the type from runtime values.
+   *
+   * Examples where we do not infer from runtime, `type` being `T` and `declaration` being `<T>` (return false):
+   *
+   * ```typescript
+   * class User<T> {
+   *     config: T;
+   * }
+   *
+   * class User<T> {
+   *    constructor(public config: T) {}
+   * }
+   *
+   * function do<T>(item: T): void {}
+   * function do<T>(item: T): T {}
+   * ```
+   *
+   * Examples where we infer from runtime (return true):
+   *
+   * ```typescript
+   * function do<T>(item: T) {
+   *     return typeOf<T>; //<-- because of that
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         config: T; //<-- because of that
+   *     }
+   *     return A;
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         doIt() {
+   *             class B {
+   *                 config: T; //<-- because of that
+   *             }
+   *             return B;
+   *         }
+   *     }
+   *     return A;
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         doIt(): T { //<-- because of that
+   *         }
+   *     }
+   *     return A;
+   * }
+   * ```
+   */
+  protected needsToBeInferred(declaration: TypeParameterDeclaration, type: TypeReferenceNode | ExpressionWithTypeArguments): boolean;
+  protected resolveTypeOnlyImport(entityName: EntityName, program: CompilerProgram): void;
+  protected resolveTypeName(typeName: string, program: CompilerProgram): void;
+  protected resolveTypeParameter(declaration: TypeParameterDeclaration, type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+  protected createAccessorForEntityName(e: QualifiedName): PropertyAccessExpression;
+  protected findDeclarationInFile(sourceFile: SourceFile$1 | ModuleDeclaration, declarationName: string): Declaration | undefined;
+  protected resolveImportSpecifier(_declarationName: string | ModuleExportName, importOrExport: ExportDeclaration | ImportDeclaration | JSDocImportTag, sourceFile: SourceFile$1): Declaration | undefined;
+  protected followExport(declarationName: string, statement: ExportDeclaration, sourceFile: SourceFile$1): Declaration | undefined;
+  protected getTypeOfType(type: Node | Declaration): Expression | undefined;
+  protected packOpsAndStack(program: CompilerProgram): ts.Expression | undefined;
+  /**
+   * Note: We have to duplicate the expressions as it can be that incoming expression are from another file and contain wrong pos/end properties,
+   * so the code generation is then broken when we simply reuse them. Wrong code like ``User.__type = [.toEqual({`` is then generated.
+   * This function is probably not complete, but we add new copies when required.
+   */
+  protected valueToExpression(value: undefined | PackExpression | PackExpression[]): Expression;
+  /**
+   * A class is decorated with type information by adding a static variable.
+   *
+   * class Model {
+   *     static __types = pack(ReflectionOp.string); //<-- encoded type information
+   *     title: string;
+   * }
+   */
+  protected decorateClass(sourceFile: SourceFile$1, node: ClassDeclaration | ClassExpression): Node;
+  /**
+   * const fn = function() {}
+   *
+   * => const fn = __assignType(function() {}, [34])
+   */
+  protected decorateFunctionExpression(expression: FunctionExpression): ts.FunctionExpression | ts.CallExpression;
+  /**
+   * function name() {}
+   *
+   * => function name() {}; name.__type = 34;
+   */
+  protected decorateFunctionDeclaration(declaration: FunctionDeclaration): ts.Statement[] | ts.FunctionDeclaration | ts.ExportAssignment | undefined;
+  /**
+   * const fn = () => {}
+   * => const fn = __assignType(() => {}, [34])
+   */
+  protected decorateArrowFunction(expression: ArrowFunction): ts.CallExpression | ts.ArrowFunction;
+  /**
+   * Object.assign(fn, {__type: []}) is much slower than a custom implementation like
+   *
+   * assignType(fn, [])
+   *
+   * where we embed assignType() at the beginning of the type.
+   */
+  protected wrapWithAssignType(fn: Expression, type: Expression): ts.CallExpression;
+  /**
+   * Checks if reflection was disabled/enabled in file via JSDoc attribute for a particular
+   * Node, e.g `@reflection no`. If nothing is found, "reflection" config option needs to be used.
+   */
+  protected getExplicitReflectionMode(sourceFile: SourceFile$1 | undefined, node: Node): boolean | undefined;
+}
+declare class DeclarationTransformer extends ReflectionTransformer {
+  protected addExports: {
+    identifier: string;
+  }[];
+  transformSourceFile(sourceFile: SourceFile$1): SourceFile$1;
+}
+declare const transformer: CustomTransformerFactory;
+declare const declarationTransformer: CustomTransformerFactory;
+//#endregion
+export { debugPackStruct as a, packSize as c, TagsReflectionStruct as i, packSizeByte as l, DeclarationTransformer as n, declarationTransformer as o, ReflectionTransformer as r, encodeOps as s, Cache as t, transformer as u };
+//# sourceMappingURL=compiler-Nkxc4PLJ.d.mts.map

package/dist/vendor/type-compiler/compiler.cjs

@@ -1,44 +1,12 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_compiler = require('./compiler-BUrWMhGi.cjs');
 
-var chunkUIWPG352_cjs = require('./chunk-UIWPG352.cjs');
-var chunkIAWCLVUK_cjs = require('./chunk-IAWCLVUK.cjs');
-
-// src/vendor/type-compiler/compiler.ts
-chunkIAWCLVUK_cjs.init_cjs_shims();
-
-Object.defineProperty(exports, "Cache", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.Cache; }
-});
-Object.defineProperty(exports, "DeclarationTransformer", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.DeclarationTransformer; }
-});
-Object.defineProperty(exports, "ReflectionTransformer", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.ReflectionTransformer; }
-});
-Object.defineProperty(exports, "debugPackStruct", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.debugPackStruct; }
-});
-Object.defineProperty(exports, "declarationTransformer", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.declarationTransformer; }
-});
-Object.defineProperty(exports, "encodeOps", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.encodeOps; }
-});
-Object.defineProperty(exports, "packSize", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.packSize; }
-});
-Object.defineProperty(exports, "packSizeByte", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.packSizeByte; }
-});
-Object.defineProperty(exports, "transformer", {
-  enumerable: true,
-  get: function () { return chunkUIWPG352_cjs.transformer; }
-});
+exports.Cache = require_compiler.Cache;
+exports.DeclarationTransformer = require_compiler.DeclarationTransformer;
+exports.ReflectionTransformer = require_compiler.ReflectionTransformer;
+exports.debugPackStruct = require_compiler.debugPackStruct;
+exports.declarationTransformer = require_compiler.declarationTransformer;
+exports.encodeOps = require_compiler.encodeOps;
+exports.packSize = require_compiler.packSize;
+exports.packSizeByte = require_compiler.packSizeByte;
+exports.transformer = require_compiler.transformer;

package/dist/vendor/type-compiler/compiler.d.cts

@@ -1,3 +1,2 @@
-export * from '@deepkit/type-compiler/compiler';
-import '@deepkit/type-compiler/config';
-import '@deepkit/type-compiler';
+import { a as debugPackStruct, c as packSize, i as TagsReflectionStruct, l as packSizeByte, n as DeclarationTransformer, o as declarationTransformer, r as ReflectionTransformer, s as encodeOps, t as Cache, u as transformer } from "./compiler-D1z5h1MK.cjs";
+export { Cache, DeclarationTransformer, ReflectionTransformer, TagsReflectionStruct, debugPackStruct, declarationTransformer, encodeOps, packSize, packSizeByte, transformer };

package/dist/vendor/type-compiler/compiler.d.mts

@@ -0,0 +1,2 @@
+import { a as debugPackStruct, c as packSize, i as TagsReflectionStruct, l as packSizeByte, n as DeclarationTransformer, o as declarationTransformer, r as ReflectionTransformer, s as encodeOps, t as Cache, u as transformer } from "./compiler-Nkxc4PLJ.mjs";
+export { Cache, DeclarationTransformer, ReflectionTransformer, TagsReflectionStruct, debugPackStruct, declarationTransformer, encodeOps, packSize, packSizeByte, transformer };

package/dist/vendor/type-compiler/compiler.mjs

@@ -0,0 +1,3 @@
+import { a as declarationTransformer, c as packSizeByte, i as debugPackStruct, l as transformer, n as DeclarationTransformer, o as encodeOps, r as ReflectionTransformer, s as packSize, t as Cache } from "./compiler-Bg8jX6qU.mjs";
+
+export { Cache, DeclarationTransformer, ReflectionTransformer, debugPackStruct, declarationTransformer, encodeOps, packSize, packSizeByte, transformer };