@powerlines/deepkit 0.7.4 → 0.7.5

package/dist/{vendor/type-compiler/compiler-BUrWMhGi.cjs → compiler-DTp8Jvav.cjs}

@@ -1,198 +1,11 @@
-const require_config = require('./config-BEX924PC.cjs');
+const require_chunk = require('./chunk-BmvPcxpV.cjs');
+const require_type = require('./type-DhqntM0q.cjs');
+const require_config = require('./config-GVyELKY1.cjs');
 let typescript = require("typescript");
-typescript = require_config.__toESM(typescript);
+typescript = require_chunk.__toESM(typescript);
 
-//#region ../../node_modules/.pnpm/@deepkit+type-spec@1.0.1_patch_hash=f3c3a4fd486751022d78f17d39a5a79f493bca20b185964ca1aba41fbfc93244/node_modules/@deepkit/type-spec/dist/esm/src/type.js
-/**
-* note: Checks are based on range checks (>, <, etc), so when adding
-* new types a check is required for all code using `TypeNumberBrand`.
-*/
-var TypeNumberBrand;
-(function(TypeNumberBrand) {
-	TypeNumberBrand[TypeNumberBrand["integer"] = 0] = "integer";
-	TypeNumberBrand[TypeNumberBrand["int8"] = 1] = "int8";
-	TypeNumberBrand[TypeNumberBrand["int16"] = 2] = "int16";
-	TypeNumberBrand[TypeNumberBrand["int32"] = 3] = "int32";
-	TypeNumberBrand[TypeNumberBrand["uint8"] = 4] = "uint8";
-	TypeNumberBrand[TypeNumberBrand["uint16"] = 5] = "uint16";
-	TypeNumberBrand[TypeNumberBrand["uint32"] = 6] = "uint32";
-	TypeNumberBrand[TypeNumberBrand["float"] = 7] = "float";
-	TypeNumberBrand[TypeNumberBrand["float32"] = 8] = "float32";
-	TypeNumberBrand[TypeNumberBrand["float64"] = 9] = "float64";
-})(TypeNumberBrand || (TypeNumberBrand = {}));
-/**
-* 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').
-*/
-var ReflectionOp;
-(function(ReflectionOp) {
-	ReflectionOp[ReflectionOp["never"] = 0] = "never";
-	ReflectionOp[ReflectionOp["any"] = 1] = "any";
-	ReflectionOp[ReflectionOp["unknown"] = 2] = "unknown";
-	ReflectionOp[ReflectionOp["void"] = 3] = "void";
-	ReflectionOp[ReflectionOp["object"] = 4] = "object";
-	ReflectionOp[ReflectionOp["string"] = 5] = "string";
-	ReflectionOp[ReflectionOp["number"] = 6] = "number";
-	ReflectionOp[ReflectionOp["numberBrand"] = 7] = "numberBrand";
-	ReflectionOp[ReflectionOp["boolean"] = 8] = "boolean";
-	ReflectionOp[ReflectionOp["bigint"] = 9] = "bigint";
-	ReflectionOp[ReflectionOp["symbol"] = 10] = "symbol";
-	ReflectionOp[ReflectionOp["null"] = 11] = "null";
-	ReflectionOp[ReflectionOp["undefined"] = 12] = "undefined";
-	/**
-	* 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.
-	*/
-	ReflectionOp[ReflectionOp["literal"] = 13] = "literal";
-	/**
-	* 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.
-	*/
-	ReflectionOp[ReflectionOp["function"] = 14] = "function";
-	/**
-	* This OP pops all types on the current stack frame.
-	*
-	* Pushes a method type.
-	*/
-	ReflectionOp[ReflectionOp["method"] = 15] = "method";
-	ReflectionOp[ReflectionOp["methodSignature"] = 16] = "methodSignature";
-	ReflectionOp[ReflectionOp["parameter"] = 17] = "parameter";
-	/**
-	* This OP pops the latest type entry on the stack.
-	*
-	* Pushes a property type.
-	*/
-	ReflectionOp[ReflectionOp["property"] = 18] = "property";
-	ReflectionOp[ReflectionOp["propertySignature"] = 19] = "propertySignature";
-	/**
-	* This OP pops all types on the current stack frame. Those types should be method|property.
-	*
-	* Pushes a TypeClass onto the stack.
-	*/
-	ReflectionOp[ReflectionOp["class"] = 20] = "class";
-	/**
-	* 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.
-	*/
-	ReflectionOp[ReflectionOp["classExtends"] = 21] = "classExtends";
-	/**
-	* This OP has 1 parameter, the stack entry to the actual class symbol.
-	*/
-	ReflectionOp[ReflectionOp["classReference"] = 22] = "classReference";
-	/**
-	* Marks the last entry in the stack as optional. Used for method|property. Equal to the QuestionMark operator in a property assignment.
-	*/
-	ReflectionOp[ReflectionOp["optional"] = 23] = "optional";
-	ReflectionOp[ReflectionOp["readonly"] = 24] = "readonly";
-	ReflectionOp[ReflectionOp["public"] = 25] = "public";
-	ReflectionOp[ReflectionOp["private"] = 26] = "private";
-	ReflectionOp[ReflectionOp["protected"] = 27] = "protected";
-	ReflectionOp[ReflectionOp["abstract"] = 28] = "abstract";
-	ReflectionOp[ReflectionOp["defaultValue"] = 29] = "defaultValue";
-	ReflectionOp[ReflectionOp["description"] = 30] = "description";
-	ReflectionOp[ReflectionOp["rest"] = 31] = "rest";
-	ReflectionOp[ReflectionOp["regexp"] = 32] = "regexp";
-	ReflectionOp[ReflectionOp["enum"] = 33] = "enum";
-	ReflectionOp[ReflectionOp["enumMember"] = 34] = "enumMember";
-	ReflectionOp[ReflectionOp["set"] = 35] = "set";
-	ReflectionOp[ReflectionOp["map"] = 36] = "map";
-	/**
-	* Pops the latest stack entry and uses it as T for an array type.
-	*
-	* Pushes an array type.
-	*/
-	ReflectionOp[ReflectionOp["array"] = 37] = "array";
-	ReflectionOp[ReflectionOp["tuple"] = 38] = "tuple";
-	ReflectionOp[ReflectionOp["tupleMember"] = 39] = "tupleMember";
-	ReflectionOp[ReflectionOp["namedTupleMember"] = 40] = "namedTupleMember";
-	ReflectionOp[ReflectionOp["union"] = 41] = "union";
-	ReflectionOp[ReflectionOp["intersection"] = 42] = "intersection";
-	ReflectionOp[ReflectionOp["indexSignature"] = 43] = "indexSignature";
-	ReflectionOp[ReflectionOp["objectLiteral"] = 44] = "objectLiteral";
-	ReflectionOp[ReflectionOp["mappedType"] = 45] = "mappedType";
-	ReflectionOp[ReflectionOp["in"] = 46] = "in";
-	ReflectionOp[ReflectionOp["frame"] = 47] = "frame";
-	ReflectionOp[ReflectionOp["moveFrame"] = 48] = "moveFrame";
-	ReflectionOp[ReflectionOp["return"] = 49] = "return";
-	ReflectionOp[ReflectionOp["templateLiteral"] = 50] = "templateLiteral";
-	ReflectionOp[ReflectionOp["date"] = 51] = "date";
-	ReflectionOp[ReflectionOp["int8Array"] = 52] = "int8Array";
-	ReflectionOp[ReflectionOp["uint8ClampedArray"] = 53] = "uint8ClampedArray";
-	ReflectionOp[ReflectionOp["uint8Array"] = 54] = "uint8Array";
-	ReflectionOp[ReflectionOp["int16Array"] = 55] = "int16Array";
-	ReflectionOp[ReflectionOp["uint16Array"] = 56] = "uint16Array";
-	ReflectionOp[ReflectionOp["int32Array"] = 57] = "int32Array";
-	ReflectionOp[ReflectionOp["uint32Array"] = 58] = "uint32Array";
-	ReflectionOp[ReflectionOp["float32Array"] = 59] = "float32Array";
-	ReflectionOp[ReflectionOp["float64Array"] = 60] = "float64Array";
-	ReflectionOp[ReflectionOp["bigInt64Array"] = 61] = "bigInt64Array";
-	ReflectionOp[ReflectionOp["arrayBuffer"] = 62] = "arrayBuffer";
-	ReflectionOp[ReflectionOp["promise"] = 63] = "promise";
-	ReflectionOp[ReflectionOp["arg"] = 64] = "arg";
-	ReflectionOp[ReflectionOp["typeParameter"] = 65] = "typeParameter";
-	ReflectionOp[ReflectionOp["typeParameterDefault"] = 66] = "typeParameterDefault";
-	ReflectionOp[ReflectionOp["var"] = 67] = "var";
-	ReflectionOp[ReflectionOp["loads"] = 68] = "loads";
-	ReflectionOp[ReflectionOp["indexAccess"] = 69] = "indexAccess";
-	ReflectionOp[ReflectionOp["keyof"] = 70] = "keyof";
-	ReflectionOp[ReflectionOp["infer"] = 71] = "infer";
-	ReflectionOp[ReflectionOp["typeof"] = 72] = "typeof";
-	ReflectionOp[ReflectionOp["condition"] = 73] = "condition";
-	ReflectionOp[ReflectionOp["jumpCondition"] = 74] = "jumpCondition";
-	ReflectionOp[ReflectionOp["jump"] = 75] = "jump";
-	ReflectionOp[ReflectionOp["call"] = 76] = "call";
-	ReflectionOp[ReflectionOp["inline"] = 77] = "inline";
-	ReflectionOp[ReflectionOp["inlineCall"] = 78] = "inlineCall";
-	ReflectionOp[ReflectionOp["distribute"] = 79] = "distribute";
-	ReflectionOp[ReflectionOp["extends"] = 80] = "extends";
-	ReflectionOp[ReflectionOp["widen"] = 81] = "widen";
-	ReflectionOp[ReflectionOp["static"] = 82] = "static";
-	ReflectionOp[ReflectionOp["mappedType2"] = 83] = "mappedType2";
-	ReflectionOp[ReflectionOp["functionReference"] = 84] = "functionReference";
-	ReflectionOp[ReflectionOp["callSignature"] = 85] = "callSignature";
-	/**
-	* 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.
-	*/
-	ReflectionOp[ReflectionOp["typeName"] = 86] = "typeName";
-	/**
-	* 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.
-	*/
-	ReflectionOp[ReflectionOp["implements"] = 87] = "implements";
-	ReflectionOp[ReflectionOp["nominal"] = 88] = "nominal";
-	/**
-	* Custom Storm Software operators
-	*/
-	ReflectionOp[ReflectionOp["tags"] = 89] = "tags";
-})(ReflectionOp || (ReflectionOp = {}));
-
-//#endregion
 //#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/vfs.cjs.production.min.js
-var require_vfs_cjs_production_min = /* @__PURE__ */ require_config.__commonJSMin(((exports) => {
+var require_vfs_cjs_production_min = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
 	function e() {
 		return e = Object.assign ? Object.assign.bind() : function(e) {
 			for (var t = 1; t < arguments.length; t++) {
@@ -644,7 +457,7 @@ var require_vfs_cjs_production_min = /* @__PURE__ */ require_config.__commonJSMi
 
 //#endregion
 //#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/vfs.cjs.development.js
-var require_vfs_cjs_development = /* @__PURE__ */ require_config.__commonJSMin(((exports) => {
+var require_vfs_cjs_development = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	function _extends() {
 		return _extends = Object.assign ? Object.assign.bind() : function(n) {
@@ -1245,7 +1058,7 @@ var require_vfs_cjs_development = /* @__PURE__ */ require_config.__commonJSMin((
 
 //#endregion
 //#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/index.js
-var require_dist = /* @__PURE__ */ require_config.__commonJSMin(((exports, module) => {
+var require_dist = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	if (process.env.NODE_ENV === "production") module.exports = require_vfs_cjs_production_min();
 	else module.exports = require_vfs_cjs_development();
 }));
@@ -5018,42 +4831,42 @@ const packSizeByte = 6;
 */
 const packSize = 2 ** 6;
 const OPs = {
-	[ReflectionOp.literal]: { params: 1 },
-	[ReflectionOp.classReference]: { params: 1 },
-	[ReflectionOp.propertySignature]: { params: 1 },
-	[ReflectionOp.property]: { params: 1 },
-	[ReflectionOp.jump]: { params: 1 },
-	[ReflectionOp.enum]: { params: 0 },
-	[ReflectionOp.enumMember]: { params: 1 },
-	[ReflectionOp.typeParameter]: { params: 1 },
-	[ReflectionOp.typeParameterDefault]: { params: 1 },
-	[ReflectionOp.mappedType]: { params: 2 },
-	[ReflectionOp.call]: { params: 1 },
-	[ReflectionOp.inline]: { params: 1 },
-	[ReflectionOp.inlineCall]: { params: 2 },
-	[ReflectionOp.loads]: { params: 2 },
-	[ReflectionOp.extends]: { params: 0 },
-	[ReflectionOp.infer]: { params: 2 },
-	[ReflectionOp.defaultValue]: { params: 1 },
-	[ReflectionOp.parameter]: { params: 1 },
-	[ReflectionOp.method]: { params: 1 },
-	[ReflectionOp.function]: { params: 1 },
-	[ReflectionOp.description]: { params: 1 },
-	[ReflectionOp.numberBrand]: { params: 1 },
-	[ReflectionOp.typeof]: { params: 1 },
-	[ReflectionOp.classExtends]: { params: 1 },
-	[ReflectionOp.distribute]: { params: 1 },
-	[ReflectionOp.jumpCondition]: { params: 2 },
-	[ReflectionOp.typeName]: { params: 1 },
-	[ReflectionOp.implements]: { params: 1 },
-	[ReflectionOp.tags]: { params: 1 }
+	[require_type.ReflectionOp.literal]: { params: 1 },
+	[require_type.ReflectionOp.classReference]: { params: 1 },
+	[require_type.ReflectionOp.propertySignature]: { params: 1 },
+	[require_type.ReflectionOp.property]: { params: 1 },
+	[require_type.ReflectionOp.jump]: { params: 1 },
+	[require_type.ReflectionOp.enum]: { params: 0 },
+	[require_type.ReflectionOp.enumMember]: { params: 1 },
+	[require_type.ReflectionOp.typeParameter]: { params: 1 },
+	[require_type.ReflectionOp.typeParameterDefault]: { params: 1 },
+	[require_type.ReflectionOp.mappedType]: { params: 2 },
+	[require_type.ReflectionOp.call]: { params: 1 },
+	[require_type.ReflectionOp.inline]: { params: 1 },
+	[require_type.ReflectionOp.inlineCall]: { params: 2 },
+	[require_type.ReflectionOp.loads]: { params: 2 },
+	[require_type.ReflectionOp.extends]: { params: 0 },
+	[require_type.ReflectionOp.infer]: { params: 2 },
+	[require_type.ReflectionOp.defaultValue]: { params: 1 },
+	[require_type.ReflectionOp.parameter]: { params: 1 },
+	[require_type.ReflectionOp.method]: { params: 1 },
+	[require_type.ReflectionOp.function]: { params: 1 },
+	[require_type.ReflectionOp.description]: { params: 1 },
+	[require_type.ReflectionOp.numberBrand]: { params: 1 },
+	[require_type.ReflectionOp.typeof]: { params: 1 },
+	[require_type.ReflectionOp.classExtends]: { params: 1 },
+	[require_type.ReflectionOp.distribute]: { params: 1 },
+	[require_type.ReflectionOp.jumpCondition]: { params: 2 },
+	[require_type.ReflectionOp.typeName]: { params: 1 },
+	[require_type.ReflectionOp.implements]: { params: 1 },
+	[require_type.ReflectionOp.tags]: { params: 1 }
 };
 function debugPackStruct(sourceFile, forType, pack) {
 	const items = [];
 	for (let i = 0; i < pack.ops.length; i++) {
 		const op = pack.ops[i];
 		const opInfo = OPs[op];
-		items.push(ReflectionOp[op]);
+		items.push(require_type.ReflectionOp[op]);
 		if (opInfo && opInfo.params > 0) for (let j = 0; j < opInfo.params; j++) {
 			const address = pack.ops[++i];
 			items.push(address);
@@ -5096,7 +4909,7 @@ var CompilerProgram = class {
 	buildPackStruct() {
 		const ops = [...this.ops];
 		if (this.coRoutines.length) for (let i = this.coRoutines.length - 1; i >= 0; i--) ops.unshift(...this.coRoutines[i].ops);
-		if (this.mainOffset) ops.unshift(ReflectionOp.jump, this.mainOffset);
+		if (this.mainOffset) ops.unshift(require_type.ReflectionOp.jump, this.mainOffset);
 		return {
 			ops,
 			stack: this.stack
@@ -5123,7 +4936,7 @@ var CompilerProgram = class {
 		this.popFrameImplicit();
 		if (this.mainOffset === 0) this.mainOffset = 2;
 		const startIndex = this.mainOffset;
-		coRoutine.ops.push(ReflectionOp.return);
+		coRoutine.ops.push(require_type.ReflectionOp.return);
 		this.coRoutines.push(coRoutine);
 		this.mainOffset += coRoutine.ops.length;
 		return startIndex;
@@ -5171,7 +4984,7 @@ var CompilerProgram = class {
 	* Each pushFrame() call needs a popFrame() call.
 	*/
 	pushFrame(implicit = false) {
-		if (!implicit) this.pushOp(ReflectionOp.frame);
+		if (!implicit) this.pushOp(require_type.ReflectionOp.frame);
 		const opIndex = this.activeCoRoutines.length ? this.activeCoRoutines[this.activeCoRoutines.length - 1].ops.length : this.ops.length;
 		this.frame = {
 			previous: this.frame,
@@ -5191,11 +5004,11 @@ var CompilerProgram = class {
 		if (this.frame.previous) this.frame = this.frame.previous;
 	}
 	moveFrame() {
-		this.pushOp(ReflectionOp.moveFrame);
+		this.pushOp(require_type.ReflectionOp.moveFrame);
 		if (this.frame.previous) this.frame = this.frame.previous;
 	}
 	pushVariable(name, frame = this.frame) {
-		this.pushOpAtFrame(frame, ReflectionOp.var);
+		this.pushOpAtFrame(frame, require_type.ReflectionOp.var);
 		frame.variables.push({
 			index: frame.variables.length,
 			name
@@ -5203,7 +5016,7 @@ var CompilerProgram = class {
 		return frame.variables.length - 1;
 	}
 	pushTemplateParameter(name, withDefault = false) {
-		this.pushOp(withDefault ? ReflectionOp.typeParameterDefault : ReflectionOp.typeParameter, this.findOrAddStackEntry(name));
+		this.pushOp(withDefault ? require_type.ReflectionOp.typeParameterDefault : require_type.ReflectionOp.typeParameter, this.findOrAddStackEntry(name));
 		this.frame.variables.push({
 			index: this.frame.variables.length,
 			name
@@ -5266,23 +5079,23 @@ var ReflectionTransformer = class {
 		this.addImports = [];
 		this.overriddenHost = false;
 		this.knownClasses = {
-			"Int8Array": ReflectionOp.int8Array,
-			"Uint8Array": ReflectionOp.uint8Array,
-			"Uint8ClampedArray": ReflectionOp.uint8ClampedArray,
-			"Int16Array": ReflectionOp.int16Array,
-			"Uint16Array": ReflectionOp.uint16Array,
-			"Int32Array": ReflectionOp.int32Array,
-			"Uint32Array": ReflectionOp.uint32Array,
-			"Float32Array": ReflectionOp.float32Array,
-			"Float64Array": ReflectionOp.float64Array,
-			"ArrayBuffer": ReflectionOp.arrayBuffer,
-			"BigInt64Array": ReflectionOp.bigInt64Array,
-			"Date": ReflectionOp.date,
-			"RegExp": ReflectionOp.regexp,
-			"String": ReflectionOp.string,
-			"Number": ReflectionOp.number,
-			"BigInt": ReflectionOp.bigint,
-			"Boolean": ReflectionOp.boolean
+			"Int8Array": require_type.ReflectionOp.int8Array,
+			"Uint8Array": require_type.ReflectionOp.uint8Array,
+			"Uint8ClampedArray": require_type.ReflectionOp.uint8ClampedArray,
+			"Int16Array": require_type.ReflectionOp.int16Array,
+			"Uint16Array": require_type.ReflectionOp.uint16Array,
+			"Int32Array": require_type.ReflectionOp.int32Array,
+			"Uint32Array": require_type.ReflectionOp.uint32Array,
+			"Float32Array": require_type.ReflectionOp.float32Array,
+			"Float64Array": require_type.ReflectionOp.float64Array,
+			"ArrayBuffer": require_type.ReflectionOp.arrayBuffer,
+			"BigInt64Array": require_type.ReflectionOp.bigInt64Array,
+			"Date": require_type.ReflectionOp.date,
+			"RegExp": require_type.ReflectionOp.regexp,
+			"String": require_type.ReflectionOp.string,
+			"Number": require_type.ReflectionOp.number,
+			"BigInt": require_type.ReflectionOp.bigint,
+			"Boolean": require_type.ReflectionOp.boolean
 		};
 		this.f = context.factory;
 		this.nodeConverter = new NodeConverter(this.f);
@@ -5591,7 +5404,7 @@ var ReflectionTransformer = class {
 			typeProgram.pushTemplateParameter(getIdentifierName(param.name), !!param.default);
 		}
 		this.extractPackStructOfType(node, typeProgram);
-		if (isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node)) typeProgram.pushOp(ReflectionOp.nominal);
+		if (isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node)) typeProgram.pushOp(require_type.ReflectionOp.nominal);
 		const typeProgramExpression = this.packOpsAndStack(typeProgram);
 		const variable = this.f.createVariableStatement([], this.f.createVariableDeclarationList([this.f.createVariableDeclaration(this.getDeclarationVariableName(name), void 0, void 0, typeProgramExpression)], NodeFlags.Const));
 		if (hasModifier(node, SyntaxKind.ExportKeyword)) return [variable, this.f.createExportDeclaration(void 0, false, this.f.createNamedExports([this.f.createExportSpecifier(false, this.getDeclarationVariableName(name), this.getDeclarationVariableName(name))]))];
@@ -5600,22 +5413,22 @@ var ReflectionTransformer = class {
 	extractPackStructOfExpression(node, program) {
 		switch (node.kind) {
 			case SyntaxKind.StringLiteral:
-				program.pushOp(ReflectionOp.string);
+				program.pushOp(require_type.ReflectionOp.string);
 				return;
 			case SyntaxKind.NumericLiteral:
-				program.pushOp(ReflectionOp.number);
+				program.pushOp(require_type.ReflectionOp.number);
 				return;
 			case SyntaxKind.FalseKeyword:
 			case SyntaxKind.TrueKeyword:
-				program.pushOp(ReflectionOp.boolean);
+				program.pushOp(require_type.ReflectionOp.boolean);
 				return;
 			case SyntaxKind.BigIntLiteral:
-				program.pushOp(ReflectionOp.bigint);
+				program.pushOp(require_type.ReflectionOp.bigint);
 				return;
 			case SyntaxKind.CallExpression: {
 				const call = node;
 				if (isIdentifier(call.expression) && getIdentifierName(call.expression) === "Symbol") {
-					program.pushOp(ReflectionOp.symbol);
+					program.pushOp(require_type.ReflectionOp.symbol);
 					return;
 				}
 				break;
@@ -5624,18 +5437,18 @@ var ReflectionTransformer = class {
 				const call = node;
 				if (isIdentifier(call.expression)) {
 					const op = {
-						"Date": ReflectionOp.date,
-						"RegExp": ReflectionOp.regexp,
-						"Uint8Array": ReflectionOp.uint8Array,
-						"Uint8ClampedArray": ReflectionOp.uint8ClampedArray,
-						"Uint16Array": ReflectionOp.uint16Array,
-						"Uint32Array": ReflectionOp.uint32Array,
-						"Int8Array": ReflectionOp.int8Array,
-						"Int16Array": ReflectionOp.int16Array,
-						"Int32Array": ReflectionOp.int32Array,
-						"Float32Array": ReflectionOp.float32Array,
-						"Float64Array": ReflectionOp.float64Array,
-						"ArrayBuffer": ReflectionOp.arrayBuffer
+						"Date": require_type.ReflectionOp.date,
+						"RegExp": require_type.ReflectionOp.regexp,
+						"Uint8Array": require_type.ReflectionOp.uint8Array,
+						"Uint8ClampedArray": require_type.ReflectionOp.uint8ClampedArray,
+						"Uint16Array": require_type.ReflectionOp.uint16Array,
+						"Uint32Array": require_type.ReflectionOp.uint32Array,
+						"Int8Array": require_type.ReflectionOp.int8Array,
+						"Int16Array": require_type.ReflectionOp.int16Array,
+						"Int32Array": require_type.ReflectionOp.int32Array,
+						"Float32Array": require_type.ReflectionOp.float32Array,
+						"Float64Array": require_type.ReflectionOp.float64Array,
+						"ArrayBuffer": require_type.ReflectionOp.arrayBuffer
 					}[getIdentifierName(call.expression)];
 					if (op) {
 						program.pushOp(op);
@@ -5645,7 +5458,7 @@ var ReflectionTransformer = class {
 				break;
 			}
 		}
-		program.pushOp(ReflectionOp.never);
+		program.pushOp(require_type.ReflectionOp.never);
 	}
 	parseDefaultValue(kind, defaultValue) {
 		switch (kind) {
@@ -5682,7 +5495,7 @@ var ReflectionTransformer = class {
 	extractTagReflections(program, node) {
 		if (!node) return;
 		const tags = this.parseTagReflection(node);
-		if (Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value?.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).length > 0) program.pushOp(ReflectionOp.tags, program.findOrAddStackEntry(this.f.createObjectLiteralExpression(this.f.createNodeArray(Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).map(([key, value]) => {
+		if (Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value?.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).length > 0) program.pushOp(require_type.ReflectionOp.tags, program.findOrAddStackEntry(this.f.createObjectLiteralExpression(this.f.createNodeArray(Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).map(([key, value]) => {
 			return this.f.createPropertyAssignment(key, Array.isArray(value) ? this.f.createArrayLiteralExpression(value.map((item) => this.valueToExpression(item))) : typeof value === "boolean" ? value ? this.f.createTrue() : this.f.createFalse() : this.valueToExpression(value));
 		})))));
 	}
@@ -5690,57 +5503,57 @@ var ReflectionTransformer = class {
 		if (!node) return;
 		let defaultValue = extractJSDocAttribute(this.sourceFile, node, "defaultValue");
 		if (!defaultValue) defaultValue = extractJSDocAttribute(this.sourceFile, node, "default");
-		if (defaultValue) program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.parseDefaultValue((node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression ? node?.name?.parent?.kind : node.kind === SyntaxKind.PropertySignature || node.kind === SyntaxKind.PropertyDeclaration ? node.type?.kind : node.kind) || SyntaxKind.StringKeyword, defaultValue.trim().replace(/^"/gm, "").replace(/"$/gm, ""))));
+		if (defaultValue) program.pushOp(require_type.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.parseDefaultValue((node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression ? node?.name?.parent?.kind : node.kind === SyntaxKind.PropertySignature || node.kind === SyntaxKind.PropertyDeclaration ? node.type?.kind : node.kind) || SyntaxKind.StringKeyword, defaultValue.trim().replace(/^"/gm, "").replace(/"$/gm, ""))));
 	}
 	extractDescriptionReflection(program, node) {
 		if (!node || this.getReflectionConfig(this.sourceFile).level !== "verbose") return;
 		const description = extractJSDocAttribute(this.sourceFile, node, "description");
-		if (description) program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description.trim().replace(/^"/gm, "").replace(/"$/gm, "")));
+		if (description) program.pushOp(require_type.ReflectionOp.description, program.findOrAddStackEntry(description.trim().replace(/^"/gm, "").replace(/"$/gm, "")));
 	}
 	extractPackStructOfType(node, program) {
 		if (isParenthesizedTypeNode(node)) return this.extractPackStructOfType(node.type, program);
 		switch (node.kind) {
 			case SyntaxKind.StringKeyword:
-				program.pushOp(ReflectionOp.string);
+				program.pushOp(require_type.ReflectionOp.string);
 				break;
 			case SyntaxKind.NumberKeyword:
-				program.pushOp(ReflectionOp.number);
+				program.pushOp(require_type.ReflectionOp.number);
 				break;
 			case SyntaxKind.BooleanKeyword:
-				program.pushOp(ReflectionOp.boolean);
+				program.pushOp(require_type.ReflectionOp.boolean);
 				break;
 			case SyntaxKind.BigIntKeyword:
-				program.pushOp(ReflectionOp.bigint);
+				program.pushOp(require_type.ReflectionOp.bigint);
 				break;
 			case SyntaxKind.VoidKeyword:
-				program.pushOp(ReflectionOp.void);
+				program.pushOp(require_type.ReflectionOp.void);
 				break;
 			case SyntaxKind.UnknownKeyword:
-				program.pushOp(ReflectionOp.unknown);
+				program.pushOp(require_type.ReflectionOp.unknown);
 				break;
 			case SyntaxKind.ObjectKeyword:
-				program.pushOp(ReflectionOp.object);
+				program.pushOp(require_type.ReflectionOp.object);
 				break;
 			case SyntaxKind.SymbolKeyword:
-				program.pushOp(ReflectionOp.symbol);
+				program.pushOp(require_type.ReflectionOp.symbol);
 				break;
 			case SyntaxKind.NullKeyword:
-				program.pushOp(ReflectionOp.null);
+				program.pushOp(require_type.ReflectionOp.null);
 				break;
 			case SyntaxKind.NeverKeyword:
-				program.pushOp(ReflectionOp.never);
+				program.pushOp(require_type.ReflectionOp.never);
 				break;
 			case SyntaxKind.AnyKeyword:
-				program.pushOp(ReflectionOp.any);
+				program.pushOp(require_type.ReflectionOp.any);
 				break;
 			case SyntaxKind.UndefinedKeyword:
-				program.pushOp(ReflectionOp.undefined);
+				program.pushOp(require_type.ReflectionOp.undefined);
 				break;
 			case SyntaxKind.TrueKeyword:
-				program.pushOp(ReflectionOp.literal, program.pushStack(this.f.createTrue()));
+				program.pushOp(require_type.ReflectionOp.literal, program.pushStack(this.f.createTrue()));
 				break;
 			case SyntaxKind.FalseKeyword:
-				program.pushOp(ReflectionOp.literal, program.pushStack(this.f.createFalse()));
+				program.pushOp(require_type.ReflectionOp.literal, program.pushStack(this.f.createFalse()));
 				break;
 			case SyntaxKind.ClassDeclaration:
 			case SyntaxKind.ClassExpression: {
@@ -5757,7 +5570,7 @@ var ReflectionTransformer = class {
 							program.pushFrame();
 							if (extendType.typeArguments) for (const typeArgument of extendType.typeArguments) this.extractPackStructOfType(typeArgument, program);
 							const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, this.nodeConverter.toExpression(extendType.expression)));
-							program.pushOp(ReflectionOp.classReference, index);
+							program.pushOp(require_type.ReflectionOp.classReference, index);
 							program.popFrameImplicit();
 						}
 					}
@@ -5769,17 +5582,17 @@ var ReflectionTransformer = class {
 						members.push(member);
 						this.extractPackStructOfType(member, program);
 					}
-					program.pushOp(ReflectionOp.class);
+					program.pushOp(require_type.ReflectionOp.class);
 					if (narrowed.heritageClauses) {
 						for (const heritageClause of narrowed.heritageClauses) if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
 							const first = heritageClause.types[0];
 							if (isExpressionWithTypeArguments(first) && first.typeArguments) {
 								for (const typeArgument of first.typeArguments) this.extractPackStructOfType(typeArgument, program);
-								program.pushOp(ReflectionOp.classExtends, first.typeArguments.length);
+								program.pushOp(require_type.ReflectionOp.classExtends, first.typeArguments.length);
 							}
 						} else if (heritageClause.token === SyntaxKind.ImplementsKeyword) {
 							for (const type of heritageClause.types) this.extractPackStructOfTypeReference(type, program);
-							program.pushOp(ReflectionOp.implements, heritageClause.types.length);
+							program.pushOp(require_type.ReflectionOp.implements, heritageClause.types.length);
 						}
 					}
 					if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
@@ -5793,7 +5606,7 @@ var ReflectionTransformer = class {
 				const narrowed = node;
 				program.pushFrame();
 				for (const type of narrowed.types) this.extractPackStructOfType(type, program);
-				program.pushOp(ReflectionOp.intersection);
+				program.pushOp(require_type.ReflectionOp.intersection);
 				program.popFrameImplicit();
 				break;
 			}
@@ -5803,7 +5616,7 @@ var ReflectionTransformer = class {
 				program.pushVariable(getIdentifierName(narrowed.typeParameter.name));
 				const constraint = getEffectiveConstraintOfTypeParameter(narrowed.typeParameter);
 				if (constraint) this.extractPackStructOfType(constraint, program);
-				else program.pushOp(ReflectionOp.never);
+				else program.pushOp(require_type.ReflectionOp.never);
 				let modifier = 0;
 				if (narrowed.questionToken) {
 					if (narrowed.questionToken.kind === SyntaxKind.QuestionToken) modifier |= 1;
@@ -5816,15 +5629,15 @@ var ReflectionTransformer = class {
 				program.pushCoRoutine();
 				if (narrowed.nameType) program.pushFrame();
 				if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
-				else program.pushOp(ReflectionOp.never);
+				else program.pushOp(require_type.ReflectionOp.never);
 				if (narrowed.nameType) {
 					this.extractPackStructOfType(narrowed.nameType, program);
-					program.pushOp(ReflectionOp.tuple);
+					program.pushOp(require_type.ReflectionOp.tuple);
 					program.popFrameImplicit();
 				}
 				const coRoutineIndex = program.popCoRoutine();
-				if (narrowed.nameType) program.pushOp(ReflectionOp.mappedType2, coRoutineIndex, modifier);
-				else program.pushOp(ReflectionOp.mappedType, coRoutineIndex, modifier);
+				if (narrowed.nameType) program.pushOp(require_type.ReflectionOp.mappedType2, coRoutineIndex, modifier);
+				else program.pushOp(require_type.ReflectionOp.mappedType, coRoutineIndex, modifier);
 				program.popFrameImplicit();
 				break;
 			}
@@ -5846,7 +5659,7 @@ var ReflectionTransformer = class {
 					for (const heritage of narrowed.heritageClauses) if (heritage.token === SyntaxKind.ExtendsKeyword) for (const extendType of heritage.types) this.extractPackStructOfTypeReference(extendType, program);
 				}
 				for (const member of narrowed.members) this.extractPackStructOfType(member, program);
-				program.pushOp(ReflectionOp.objectLiteral);
+				program.pushOp(require_type.ReflectionOp.objectLiteral);
 				if (isTypeLiteralNode(narrowed)) descriptionNode = narrowed.parent;
 				this.extractDefaultValueReflection(program, descriptionNode);
 				this.extractDescriptionReflection(program, descriptionNode);
@@ -5862,33 +5675,33 @@ var ReflectionTransformer = class {
 				break;
 			case SyntaxKind.ArrayType:
 				this.extractPackStructOfType(node.elementType, program);
-				program.pushOp(ReflectionOp.array);
+				program.pushOp(require_type.ReflectionOp.array);
 				break;
 			case SyntaxKind.RestType: {
 				let type = node.type;
 				if (isArrayTypeNode(type)) type = type.elementType;
 				this.extractPackStructOfType(type, program);
-				program.pushOp(ReflectionOp.rest);
+				program.pushOp(require_type.ReflectionOp.rest);
 				break;
 			}
 			case SyntaxKind.TupleType:
 				program.pushFrame();
 				for (const element of node.elements) if (isOptionalTypeNode(element)) {
 					this.extractPackStructOfType(element.type, program);
-					program.pushOp(ReflectionOp.tupleMember);
-					program.pushOp(ReflectionOp.optional);
+					program.pushOp(require_type.ReflectionOp.tupleMember);
+					program.pushOp(require_type.ReflectionOp.optional);
 				} else if (isNamedTupleMember(element)) {
 					if (element.dotDotDotToken) {
 						let type = element.type;
 						if (isArrayTypeNode(type)) type = type.elementType;
 						this.extractPackStructOfType(type, program);
-						program.pushOp(ReflectionOp.rest);
+						program.pushOp(require_type.ReflectionOp.rest);
 					} else this.extractPackStructOfType(element.type, program);
 					const index = program.findOrAddStackEntry(getIdentifierName(element.name));
-					program.pushOp(ReflectionOp.namedTupleMember, index);
-					if (element.questionToken) program.pushOp(ReflectionOp.optional);
+					program.pushOp(require_type.ReflectionOp.namedTupleMember, index);
+					if (element.questionToken) program.pushOp(require_type.ReflectionOp.optional);
 				} else this.extractPackStructOfType(element, program);
-				program.pushOp(ReflectionOp.tuple);
+				program.pushOp(require_type.ReflectionOp.tuple);
 				program.popFrameImplicit();
 				break;
 			case SyntaxKind.PropertySignature: {
@@ -5896,14 +5709,14 @@ var ReflectionTransformer = class {
 				if (narrowed.type) {
 					this.extractPackStructOfType(narrowed.type, program);
 					const name = getPropertyName(this.f, narrowed.name);
-					program.pushOp(ReflectionOp.propertySignature, program.findOrAddStackEntry(name));
-					if (narrowed.questionToken) program.pushOp(ReflectionOp.optional);
-					if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
-					else if (extractJSDocBoolean(this.sourceFile, narrowed, "readonly")) program.pushOp(ReflectionOp.readonly);
+					program.pushOp(require_type.ReflectionOp.propertySignature, program.findOrAddStackEntry(name));
+					if (narrowed.questionToken) program.pushOp(require_type.ReflectionOp.optional);
+					if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(require_type.ReflectionOp.readonly);
+					else if (extractJSDocBoolean(this.sourceFile, narrowed, "readonly")) program.pushOp(require_type.ReflectionOp.readonly);
 					this.extractDefaultValueReflection(program, narrowed);
 					this.extractDescriptionReflection(program, narrowed);
 					this.extractTagReflections(program, narrowed);
-				} else program.pushOp(ReflectionOp.unknown);
+				} else program.pushOp(require_type.ReflectionOp.unknown);
 				break;
 			}
 			case SyntaxKind.PropertyDeclaration: {
@@ -5911,16 +5724,16 @@ var ReflectionTransformer = class {
 				if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) return;
 				if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
 				else if (narrowed.initializer) this.extractPackStructOfExpression(narrowed.initializer, program);
-				else program.pushOp(ReflectionOp.unknown);
-				program.pushOp(ReflectionOp.property, program.findOrAddStackEntry(getPropertyName(this.f, narrowed.name)));
-				if (narrowed.questionToken) program.pushOp(ReflectionOp.optional);
-				if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
-				else if (extractJSDocBoolean(this.sourceFile, narrowed, "readonly")) program.pushOp(ReflectionOp.readonly);
-				if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(ReflectionOp.private);
-				if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
-				if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
-				if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(ReflectionOp.static);
-				if (narrowed.initializer) program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, this.f.createBlock([this.f.createReturnStatement(narrowed.initializer)]))));
+				else program.pushOp(require_type.ReflectionOp.unknown);
+				program.pushOp(require_type.ReflectionOp.property, program.findOrAddStackEntry(getPropertyName(this.f, narrowed.name)));
+				if (narrowed.questionToken) program.pushOp(require_type.ReflectionOp.optional);
+				if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(require_type.ReflectionOp.readonly);
+				else if (extractJSDocBoolean(this.sourceFile, narrowed, "readonly")) program.pushOp(require_type.ReflectionOp.readonly);
+				if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(require_type.ReflectionOp.private);
+				if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(require_type.ReflectionOp.protected);
+				if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(require_type.ReflectionOp.abstract);
+				if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(require_type.ReflectionOp.static);
+				if (narrowed.initializer) program.pushOp(require_type.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, this.f.createBlock([this.f.createReturnStatement(narrowed.initializer)]))));
 				else this.extractDefaultValueReflection(program, narrowed);
 				this.extractDescriptionReflection(program, narrowed);
 				this.extractTagReflections(program, narrowed);
@@ -5938,18 +5751,18 @@ var ReflectionTransformer = class {
 				program.pushConditionalFrame();
 				this.extractPackStructOfType(narrowed.checkType, program);
 				this.extractPackStructOfType(narrowed.extendsType, program);
-				program.pushOp(ReflectionOp.extends);
+				program.pushOp(require_type.ReflectionOp.extends);
 				program.pushCoRoutine();
 				this.extractPackStructOfType(narrowed.trueType, program);
 				const trueProgram = program.popCoRoutine();
 				program.pushCoRoutine();
 				this.extractPackStructOfType(narrowed.falseType, program);
 				const falseProgram = program.popCoRoutine();
-				program.pushOp(ReflectionOp.jumpCondition, trueProgram, falseProgram);
+				program.pushOp(require_type.ReflectionOp.jumpCondition, trueProgram, falseProgram);
 				program.moveFrame();
 				if (distributiveOverIdentifier) {
 					const coRoutineIndex = program.popCoRoutine();
-					program.pushOp(ReflectionOp.distribute, coRoutineIndex);
+					program.pushOp(require_type.ReflectionOp.distribute, coRoutineIndex);
 					program.popFrameImplicit();
 				}
 				break;
@@ -5965,8 +5778,8 @@ var ReflectionTransformer = class {
 						variable = program.findVariable(typeParameterName);
 						if (!variable) throw new Error("Could not find inserted infer variable");
 					}
-					program.pushOp(ReflectionOp.infer, variable.frameOffset, variable.stackIndex);
-				} else program.pushOp(ReflectionOp.never);
+					program.pushOp(require_type.ReflectionOp.infer, variable.frameOffset, variable.stackIndex);
+				} else program.pushOp(require_type.ReflectionOp.never);
 				break;
 			}
 			case SyntaxKind.MethodSignature:
@@ -5981,7 +5794,7 @@ var ReflectionTransformer = class {
 			case SyntaxKind.FunctionDeclaration: {
 				const narrowed = node;
 				if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) {
-					program.pushOp(ReflectionOp.any);
+					program.pushOp(require_type.ReflectionOp.any);
 					return;
 				}
 				const name = isCallSignatureDeclaration(node) ? "" : isConstructorTypeNode(narrowed) || isConstructSignatureDeclaration(node) ? "new" : isConstructorDeclaration(narrowed) ? "constructor" : getPropertyName(this.f, narrowed.name);
@@ -5992,34 +5805,34 @@ var ReflectionTransformer = class {
 					const parameterName = isIdentifier(parameter.name) ? getNameAsString(parameter.name) : "param" + i;
 					const type = parameter.type ? parameter.dotDotDotToken && isArrayTypeNode(parameter.type) ? parameter.type.elementType : parameter.type : void 0;
 					if (type) this.extractPackStructOfType(type, program);
-					else program.pushOp(ReflectionOp.any);
-					if (parameter.dotDotDotToken) program.pushOp(ReflectionOp.rest);
-					program.pushOp(ReflectionOp.parameter, program.findOrAddStackEntry(parameterName));
-					if (parameter.questionToken) program.pushOp(ReflectionOp.optional);
-					if (hasModifier(parameter, SyntaxKind.PublicKeyword)) program.pushOp(ReflectionOp.public);
-					if (hasModifier(parameter, SyntaxKind.PrivateKeyword)) program.pushOp(ReflectionOp.private);
-					if (hasModifier(parameter, SyntaxKind.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
-					if (hasModifier(parameter, SyntaxKind.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
+					else program.pushOp(require_type.ReflectionOp.any);
+					if (parameter.dotDotDotToken) program.pushOp(require_type.ReflectionOp.rest);
+					program.pushOp(require_type.ReflectionOp.parameter, program.findOrAddStackEntry(parameterName));
+					if (parameter.questionToken) program.pushOp(require_type.ReflectionOp.optional);
+					if (hasModifier(parameter, SyntaxKind.PublicKeyword)) program.pushOp(require_type.ReflectionOp.public);
+					if (hasModifier(parameter, SyntaxKind.PrivateKeyword)) program.pushOp(require_type.ReflectionOp.private);
+					if (hasModifier(parameter, SyntaxKind.ProtectedKeyword)) program.pushOp(require_type.ReflectionOp.protected);
+					if (hasModifier(parameter, SyntaxKind.ReadonlyKeyword)) program.pushOp(require_type.ReflectionOp.readonly);
 					else {
 						let readonly = extractJSDocBoolean(this.sourceFile, parameter, "readonly");
-						if (readonly) program.pushOp(ReflectionOp.readonly);
+						if (readonly) program.pushOp(require_type.ReflectionOp.readonly);
 						else {
 							readonly = extractJSDocBoolean(this.sourceFile, narrowed, "readonly");
-							if (readonly) program.pushOp(ReflectionOp.readonly);
+							if (readonly) program.pushOp(require_type.ReflectionOp.readonly);
 						}
 					}
-					if (parameter.initializer && parameter.type && !getReceiveTypeParameter(parameter.type)) program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, parameter.initializer)));
+					if (parameter.initializer && parameter.type && !getReceiveTypeParameter(parameter.type)) program.pushOp(require_type.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, parameter.initializer)));
 					else this.extractDefaultValueReflection(program, parameter);
 					this.extractDescriptionReflection(program, parameter);
 				}
 				if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
-				else program.pushOp(ReflectionOp.any);
-				program.pushOp(isCallSignatureDeclaration(node) ? ReflectionOp.callSignature : isMethodSignature(narrowed) || isConstructSignatureDeclaration(narrowed) ? ReflectionOp.methodSignature : isMethodDeclaration(narrowed) || isConstructorDeclaration(narrowed) ? ReflectionOp.method : ReflectionOp.function, program.findOrAddStackEntry(name));
+				else program.pushOp(require_type.ReflectionOp.any);
+				program.pushOp(isCallSignatureDeclaration(node) ? require_type.ReflectionOp.callSignature : isMethodSignature(narrowed) || isConstructSignatureDeclaration(narrowed) ? require_type.ReflectionOp.methodSignature : isMethodDeclaration(narrowed) || isConstructorDeclaration(narrowed) ? require_type.ReflectionOp.method : require_type.ReflectionOp.function, program.findOrAddStackEntry(name));
 				if (isMethodDeclaration(narrowed)) {
-					if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(ReflectionOp.private);
-					if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
-					if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
-					if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(ReflectionOp.static);
+					if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(require_type.ReflectionOp.private);
+					if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(require_type.ReflectionOp.protected);
+					if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(require_type.ReflectionOp.abstract);
+					if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(require_type.ReflectionOp.static);
 				}
 				this.extractDefaultValueReflection(program, narrowed);
 				this.extractDescriptionReflection(program, narrowed);
@@ -6029,19 +5842,19 @@ var ReflectionTransformer = class {
 			}
 			case SyntaxKind.LiteralType: {
 				const narrowed = node;
-				if (narrowed.literal.kind === SyntaxKind.NullKeyword) program.pushOp(ReflectionOp.null);
-				else program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(narrowed.literal));
+				if (narrowed.literal.kind === SyntaxKind.NullKeyword) program.pushOp(require_type.ReflectionOp.null);
+				else program.pushOp(require_type.ReflectionOp.literal, program.findOrAddStackEntry(narrowed.literal));
 				break;
 			}
 			case SyntaxKind.TemplateLiteralType: {
 				const narrowed = node;
 				program.pushFrame();
-				if (narrowed.head.rawText) program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(narrowed.head.rawText));
+				if (narrowed.head.rawText) program.pushOp(require_type.ReflectionOp.literal, program.findOrAddStackEntry(narrowed.head.rawText));
 				for (const span of narrowed.templateSpans) {
 					this.extractPackStructOfType(span.type, program);
-					if (span.literal.rawText) program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(span.literal.rawText));
+					if (span.literal.rawText) program.pushOp(require_type.ReflectionOp.literal, program.findOrAddStackEntry(span.literal.rawText));
 				}
-				program.pushOp(ReflectionOp.templateLiteral);
+				program.pushOp(require_type.ReflectionOp.templateLiteral);
 				program.popFrameImplicit();
 				break;
 			}
@@ -6051,7 +5864,7 @@ var ReflectionTransformer = class {
 				else {
 					program.pushFrame();
 					for (const subType of narrowed.types) this.extractPackStructOfType(subType, program);
-					program.pushOp(ReflectionOp.union);
+					program.pushOp(require_type.ReflectionOp.union);
 					program.popFrameImplicit();
 				}
 				break;
@@ -6061,11 +5874,11 @@ var ReflectionTransformer = class {
 				program.pushFrame();
 				for (const type of narrowed.members) {
 					const name = getPropertyName(this.f, type.name);
-					program.pushOp(ReflectionOp.enumMember, program.findOrAddStackEntry(name));
+					program.pushOp(require_type.ReflectionOp.enumMember, program.findOrAddStackEntry(name));
 					this.extractDescriptionReflection(program, type);
-					if (type.initializer) program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, type.initializer)));
+					if (type.initializer) program.pushOp(require_type.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, type.initializer)));
 				}
-				program.pushOp(ReflectionOp.enum);
+				program.pushOp(require_type.ReflectionOp.enum);
 				this.extractDefaultValueReflection(program, narrowed);
 				this.extractDescriptionReflection(program, narrowed);
 				this.extractTagReflections(program, narrowed);
@@ -6076,9 +5889,9 @@ var ReflectionTransformer = class {
 			case SyntaxKind.IndexSignature: {
 				const narrowed = node;
 				if (narrowed.parameters.length && narrowed.parameters[0].type) this.extractPackStructOfType(narrowed.parameters[0].type, program);
-				else program.pushOp(ReflectionOp.any);
+				else program.pushOp(require_type.ReflectionOp.any);
 				this.extractPackStructOfType(narrowed.type, program);
-				program.pushOp(ReflectionOp.indexSignature);
+				program.pushOp(require_type.ReflectionOp.indexSignature);
 				break;
 			}
 			case SyntaxKind.TypeQuery: {
@@ -6088,25 +5901,25 @@ var ReflectionTransformer = class {
 					if (resolved && findSourceFile(resolved.declaration) !== this.sourceFile && resolved.importDeclaration) ensureImportIsEmitted(resolved.importDeclaration, narrowed.exprName);
 				}
 				const expression = serializeEntityNameAsExpression(this.f, narrowed.exprName);
-				program.pushOp(ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, expression)));
+				program.pushOp(require_type.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, expression)));
 				break;
 			}
 			case SyntaxKind.TypeOperator: {
 				const narrowed = node;
 				if (narrowed.type.kind === SyntaxKind.ThisType) {
-					program.pushOp(ReflectionOp.any);
+					program.pushOp(require_type.ReflectionOp.any);
 					break;
 				}
 				switch (narrowed.operator) {
 					case SyntaxKind.KeyOfKeyword:
 						this.extractPackStructOfType(narrowed.type, program);
-						program.pushOp(ReflectionOp.keyof);
+						program.pushOp(require_type.ReflectionOp.keyof);
 						break;
 					case SyntaxKind.ReadonlyKeyword:
 						this.extractPackStructOfType(narrowed.type, program);
-						program.pushOp(ReflectionOp.readonly);
+						program.pushOp(require_type.ReflectionOp.readonly);
 						break;
-					default: program.pushOp(ReflectionOp.never);
+					default: program.pushOp(require_type.ReflectionOp.never);
 				}
 				break;
 			}
@@ -6114,17 +5927,17 @@ var ReflectionTransformer = class {
 				const narrowed = node;
 				this.extractPackStructOfType(narrowed.objectType, program);
 				this.extractPackStructOfType(narrowed.indexType, program);
-				program.pushOp(ReflectionOp.indexAccess);
+				program.pushOp(require_type.ReflectionOp.indexAccess);
 				break;
 			}
 			case SyntaxKind.Identifier: {
 				const narrowed = node;
 				const variable = program.findVariable(getIdentifierName(narrowed));
-				if (variable) program.pushOp(ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
-				else program.pushOp(ReflectionOp.never);
+				if (variable) program.pushOp(require_type.ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
+				else program.pushOp(require_type.ReflectionOp.never);
 				break;
 			}
-			default: program.pushOp(ReflectionOp.never);
+			default: program.pushOp(require_type.ReflectionOp.never);
 		}
 	}
 	getGlobalLibs() {
@@ -6225,12 +6038,12 @@ var ReflectionTransformer = class {
 	extractPackStructOfTypeReference(type, program) {
 		const typeName = isTypeReferenceNode(type) ? type.typeName : isIdentifier(type.expression) ? type.expression : void 0;
 		if (!typeName) {
-			program.pushOp(ReflectionOp.any);
+			program.pushOp(require_type.ReflectionOp.any);
 			return;
 		}
 		if (isIdentifier(typeName) && getIdentifierName(typeName) === "InlineRuntimeType" && type.typeArguments && type.typeArguments[0] && isTypeQueryNode(type.typeArguments[0])) {
 			const expression = serializeEntityNameAsExpression(this.f, type.typeArguments[0].exprName);
-			program.pushOp(ReflectionOp.arg, program.pushStack(expression));
+			program.pushOp(require_type.ReflectionOp.arg, program.pushStack(expression));
 			return;
 		}
 		if (isIdentifier(typeName) && getIdentifierName(typeName) !== "constructor" && this.knownClasses[getIdentifierName(typeName)]) {
@@ -6239,15 +6052,15 @@ var ReflectionTransformer = class {
 			program.pushOp(op);
 		} else if (isIdentifier(typeName) && getIdentifierName(typeName) === "Promise") {
 			if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
-			else program.pushOp(ReflectionOp.any);
-			program.pushOp(ReflectionOp.promise);
-		} else if (isIdentifier(typeName) && getIdentifierName(typeName) === "integer") program.pushOp(ReflectionOp.numberBrand, TypeNumberBrand.integer);
-		else if (isIdentifier(typeName) && getIdentifierName(typeName) !== "constructor" && TypeNumberBrand[getIdentifierName(typeName)] !== void 0) program.pushOp(ReflectionOp.numberBrand, TypeNumberBrand[getIdentifierName(typeName)]);
+			else program.pushOp(require_type.ReflectionOp.any);
+			program.pushOp(require_type.ReflectionOp.promise);
+		} else if (isIdentifier(typeName) && getIdentifierName(typeName) === "integer") program.pushOp(require_type.ReflectionOp.numberBrand, require_type.TypeNumberBrand.integer);
+		else if (isIdentifier(typeName) && getIdentifierName(typeName) !== "constructor" && require_type.TypeNumberBrand[getIdentifierName(typeName)] !== void 0) program.pushOp(require_type.ReflectionOp.numberBrand, require_type.TypeNumberBrand[getIdentifierName(typeName)]);
 		else {
 			if (isIdentifier(typeName)) {
 				const variable = program.findVariable(getIdentifierName(typeName));
 				if (variable) {
-					program.pushOp(ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
+					program.pushOp(require_type.ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
 					return;
 				}
 			} else if (isInferTypeNode(typeName)) {
@@ -6263,11 +6076,11 @@ var ReflectionTransformer = class {
 							let lastExpression;
 							let indexValue = 0;
 							for (const member of resolved.declaration.members) if (getNameAsString(member.name) === getNameAsString(typeName.right)) {
-								if (member.initializer) program.pushOp(ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(member.initializer)));
+								if (member.initializer) program.pushOp(require_type.ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(member.initializer)));
 								else if (lastExpression) {
 									const exp = this.nodeConverter.toExpression(lastExpression);
-									program.pushOp(ReflectionOp.arg, program.pushStack(this.f.createBinaryExpression(exp, SyntaxKind.PlusToken, this.nodeConverter.toExpression(indexValue))));
-								} else program.pushOp(ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(indexValue)));
+									program.pushOp(require_type.ReflectionOp.arg, program.pushStack(this.f.createBinaryExpression(exp, SyntaxKind.PlusToken, this.nodeConverter.toExpression(indexValue))));
+								} else program.pushOp(require_type.ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(indexValue)));
 								return;
 							} else {
 								indexValue++;
@@ -6279,7 +6092,7 @@ var ReflectionTransformer = class {
 						}
 					}
 				}
-				program.pushOp(ReflectionOp.never);
+				program.pushOp(require_type.ReflectionOp.never);
 				require_config.debug2(`Could not resolve ${getNameAsString(typeName)} in ${program.sourceFile?.fileName || "intrinsic"}`);
 				return;
 			}
@@ -6293,37 +6106,37 @@ var ReflectionTransformer = class {
 			}
 			if (isModuleDeclaration(declaration) && resolved.importDeclaration) {
 				if (isIdentifier(typeName)) ensureImportIsEmitted(resolved.importDeclaration, typeName);
-				program.pushOp(ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, serializeEntityNameAsExpression(this.f, typeName))));
+				program.pushOp(require_type.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, serializeEntityNameAsExpression(this.f, typeName))));
 			} else if (isTypeAliasDeclaration(declaration) || isInterfaceDeclaration(declaration) || isEnumDeclaration(declaration)) {
 				const name = getNameAsString(typeName);
 				if (name === "Array") {
 					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
-					else program.pushOp(ReflectionOp.any);
-					program.pushOp(ReflectionOp.array);
+					else program.pushOp(require_type.ReflectionOp.any);
+					program.pushOp(require_type.ReflectionOp.array);
 					return;
 				} else if (name === "Function") {
 					program.pushFrame();
 					const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, this.f.createIdentifier("Function")));
-					program.pushOp(ReflectionOp.functionReference, index);
+					program.pushOp(require_type.ReflectionOp.functionReference, index);
 					program.popFrameImplicit();
 					return;
 				} else if (name === "Set") {
 					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
-					else program.pushOp(ReflectionOp.any);
-					program.pushOp(ReflectionOp.set);
+					else program.pushOp(require_type.ReflectionOp.any);
+					program.pushOp(require_type.ReflectionOp.set);
 					return;
 				} else if (name === "Map") {
 					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
-					else program.pushOp(ReflectionOp.any);
+					else program.pushOp(require_type.ReflectionOp.any);
 					if (type.typeArguments && type.typeArguments[1]) this.extractPackStructOfType(type.typeArguments[1], program);
-					else program.pushOp(ReflectionOp.any);
-					program.pushOp(ReflectionOp.map);
+					else program.pushOp(require_type.ReflectionOp.any);
+					program.pushOp(require_type.ReflectionOp.map);
 					return;
 				}
 				const runtimeTypeName = this.getDeclarationVariableName(typeName);
 				if (!this.compiledDeclarations.has(declaration) && !this.compileDeclarations.has(declaration)) {
 					if (declarationSourceFile && this.isExcluded(declarationSourceFile.fileName)) {
-						program.pushOp(ReflectionOp.any);
+						program.pushOp(require_type.ReflectionOp.any);
 						return;
 					}
 					if (isGlobal) this.embedDeclarations.set(declaration, {
@@ -6375,8 +6188,8 @@ var ReflectionTransformer = class {
 				const index = program.pushStack(program.forNode === declaration ? 0 : this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, runtimeTypeName));
 				if (type.typeArguments) {
 					for (const argument of type.typeArguments) this.extractPackStructOfType(argument, program);
-					program.pushOp(ReflectionOp.inlineCall, index, type.typeArguments.length);
-				} else program.pushOp(ReflectionOp.inline, index);
+					program.pushOp(require_type.ReflectionOp.inlineCall, index, type.typeArguments.length);
+				} else program.pushOp(require_type.ReflectionOp.inline, index);
 			} else if (isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isFunctionExpression(declaration) || isArrowFunction(declaration)) {
 				if (resolved.typeOnly) {
 					this.resolveTypeOnlyImport(typeName, program);
@@ -6391,7 +6204,7 @@ var ReflectionTransformer = class {
 				if (type.typeArguments) for (const typeArgument of type.typeArguments) this.extractPackStructOfType(typeArgument, program);
 				const body = isIdentifier(typeName) ? typeName : this.createAccessorForEntityName(typeName);
 				const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, body));
-				program.pushOp(isClassDeclaration(declaration) ? ReflectionOp.classReference : ReflectionOp.functionReference, index);
+				program.pushOp(isClassDeclaration(declaration) ? require_type.ReflectionOp.classReference : require_type.ReflectionOp.functionReference, index);
 				program.popFrameImplicit();
 			} else if (isTypeParameterDeclaration(declaration)) this.resolveTypeParameter(declaration, type, program);
 			else this.extractPackStructOfType(declaration, program);
@@ -6471,13 +6284,13 @@ var ReflectionTransformer = class {
 		return this.getTypeUser(declaration) !== this.getTypeUser(type);
 	}
 	resolveTypeOnlyImport(entityName, program) {
-		program.pushOp(ReflectionOp.any);
+		program.pushOp(require_type.ReflectionOp.any);
 		const typeName = typescript.default.isIdentifier(entityName) ? getIdentifierName(entityName) : getIdentifierName(entityName.right);
 		this.resolveTypeName(typeName, program);
 	}
 	resolveTypeName(typeName, program) {
 		if (!typeName) return;
-		program.pushOp(ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
+		program.pushOp(require_type.ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
 	}
 	resolveTypeParameter(declaration, type, program) {
 		const isUsedInFunction = isFunctionLike(declaration.parent);
@@ -6506,16 +6319,16 @@ var ReflectionTransformer = class {
 			if (foundUsers.length) {
 				if (foundUsers.length > 1) {}
 				const isReceiveType = foundUsers.find((v) => isTypeReferenceNode(v.type) && isIdentifier(v.type.typeName) && getIdentifierName(v.type.typeName) === "ReceiveType");
-				if (isReceiveType) program.pushOp(ReflectionOp.inline, program.pushStack(isReceiveType.parameterName));
+				if (isReceiveType) program.pushOp(require_type.ReflectionOp.inline, program.pushStack(isReceiveType.parameterName));
 				else for (const foundUser of foundUsers) {
 					program.pushConditionalFrame();
-					program.pushOp(ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, foundUser.parameterName)));
+					program.pushOp(require_type.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, foundUser.parameterName)));
 					this.extractPackStructOfType(foundUser.type, program);
-					program.pushOp(ReflectionOp.extends);
+					program.pushOp(require_type.ReflectionOp.extends);
 					if (program.findVariable(getIdentifierName(declaration.name))) this.extractPackStructOfType(declaration.name, program);
-					else program.pushOp(ReflectionOp.any);
+					else program.pushOp(require_type.ReflectionOp.any);
 					this.extractPackStructOfType({ kind: SyntaxKind.NeverKeyword }, program);
-					program.pushOp(ReflectionOp.condition);
+					program.pushOp(require_type.ReflectionOp.condition);
 					program.popFrameImplicit();
 				}
 				if (foundUsers.length > 1) {}
@@ -6523,10 +6336,10 @@ var ReflectionTransformer = class {
 				if (isUsedInFunction) program.resolveFunctionParametersIncrease(declaration.parent);
 				const constraint = getEffectiveConstraintOfTypeParameter(declaration);
 				if (constraint) this.extractPackStructOfType(constraint, program);
-				else program.pushOp(ReflectionOp.never);
+				else program.pushOp(require_type.ReflectionOp.never);
 				if (isUsedInFunction) program.resolveFunctionParametersDecrease(declaration.parent);
-			} else program.pushOp(ReflectionOp.never);
-		} else program.pushOp(ReflectionOp.any);
+			} else program.pushOp(require_type.ReflectionOp.never);
+		} else program.pushOp(require_type.ReflectionOp.any);
 	}
 	createAccessorForEntityName(e) {
 		return this.f.createPropertyAccessExpression(isIdentifier(e.left) ? e.left : this.createAccessorForEntityName(e.left), e.right);