zod-compiler 0.1.0 → 1.0.0

package/dist/index.js

@@ -1,2550 +1,2 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var ts = require('typescript');
-var standalone = require('./standalone.js');
-var _apply_decs_2203_r = require('@swc/helpers/_/_apply_decs_2203_r');
-var z = require('zod');
-var _identity = require('@swc/helpers/_/_identity');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var ts__default = /*#__PURE__*/_interopDefault(ts);
-var standalone__default = /*#__PURE__*/_interopDefault(standalone);
-var z__default = /*#__PURE__*/_interopDefault(z);
-
-function uniqueIdentifier(name) {
-    return ts.factory.createUniqueName(name, ts__default.default.GeneratedIdentifierFlags.ReservedInNestedScopes);
-}
-function local(ident, initializer, modifiable = false) {
-    return ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ident, undefined, undefined, initializer)
-    ], !modifiable ? ts.NodeFlags.Const : ts.NodeFlags.Let));
-}
-function objectLiteral(obj) {
-    const entries = Object.entries(obj).filter(([k, v])=>!!v);
-    return ts.factory.createObjectLiteralExpression(entries.map(([name, expr])=>ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(name), expr)), entries.length > 1);
-}
-const IDENT_REGEX = /^[$A-Z_a-z][\w$]*$/;
-function identifierOrStringLiteral(value) {
-    if (IDENT_REGEX.test(value)) {
-        return ts.factory.createIdentifier(value);
-    } else {
-        return ts.factory.createStringLiteral(value);
-    }
-}
-function propertyChain(start, elements) {
-    for (let element of elements){
-        if (typeof element === 'string') {
-            if (IDENT_REGEX.test(element)) {
-                start = ts.factory.createPropertyAccessExpression(start, element);
-                continue;
-            }
-            element = ts.factory.createStringLiteral(element);
-        }
-        start = ts.factory.createElementAccessExpression(start, element);
-    }
-    return start;
-}
-function print(node, hint = ts.EmitHint.Unspecified) {
-    const file = ts__default.default.createSourceFile('print.ts', '', ts.ScriptTarget.ES2022, false, ts.ScriptKind.TS);
-    const printer = ts__default.default.createPrinter();
-    return printer.printNode(hint, node, file);
-}
-function callHelper(verifierContext, helper, ...args) {
-    return ts.factory.createCallExpression(propertyChain(verifierContext, [
-        'helpers',
-        helper
-    ]), undefined, args);
-}
-class Path {
-    constructor(parts){
-        this.parts = parts;
-    }
-    static empty() {
-        return new Path([]);
-    }
-    get isEmpty() {
-        return this.parts.length === 0;
-    }
-    clone() {
-        return new Path([
-            ...this.parts
-        ]);
-    }
-    push(fragment) {
-        const parts = [
-            ...this.parts
-        ];
-        if (typeof fragment === 'string') {
-            parts.push(ts.factory.createStringLiteral(fragment));
-        } else if (typeof fragment === 'number') {
-            parts.push(ts.factory.createNumericLiteral(fragment, ts.TokenFlags.None));
-        } else {
-            parts.push(fragment);
-        }
-        return new Path(parts);
-    }
-    serialize() {
-        return ts.factory.createArrayLiteralExpression(this.parts, false);
-    }
-}
-
-/**
- * In JavaScript, there exist two main types of values - primitives like strings, numbers, and booleans; and objects like
- * arrays, `Map`s, `Set`s, and, well, *objects*. Two primitives with equal value are equal to each other: `42 === 42` and
- * `"foo" === "foo"`, however ***two objects will never be equal to each other***: `{} !== {}`, `[] !== []`.
- * 
- * Since `zod-compiler` outputs source code which is then {@linkcode eval}uated, it has to get values defined in types
- * like `z.literal()` or `.default()` or `.catch()` from *somewhere*; for primitive types this is fine, and the value can
- * be directly pasted into the source code. However, for objects, this can lead to unexpected behavior if you, for example,
- * expect values returned by `.default()` to be equal to the original value provided in the schema definition.
- * 
- * The default inlining mode is {@linkcode Default}, which inlines *primitives*, but not *objects*. This means that
- * any object values are defined as a **dependency**; they are the *exact same values* taken from the schema definition
- * that the compiled parser can use via a reference. This behavior provides the best compatibility for in-source usage of
- * `zod-compiler`.
- * 
- * For **standalone** builds, however, that would mean that you'd have to provide these dependency references to the parser.
- * `zc.compile()` returns a dependency array which you could then pass to `standalone()`, though you'd have to figure
- * out where those values come from and extract them out of your source tree. Alternatively, the {@linkcode InliningMode.Aggressive Aggressive}
- * inlining mode *will* attempt to inline objects, arrays, `Map`s, and `Set`s. This does mean that these values would
- * no longer be equivalent to their definition, but there's a good chance you don't depend on that behavior anyway.
- */ var InliningMode = /*#__PURE__*/ function(InliningMode) {
-    /** Does not inline any values; they will all be added as dependencies. */ InliningMode[InliningMode["None"] = 0] = "None";
-    /** Inlines most primitives: strings, numbers, `BigInt`s, booleans, and `null`/`undefined`. */ InliningMode[InliningMode["Default"] = 1] = "Default";
-    /**
-	 * Like {@linkcode InliningMode.Default Default}, but also inlines objects, arrays, `Map`s and `Set`s, and regular
-	 * expressions.
-	 * 
-	 * Symbols and functions cannot be inlined.
-	 */ InliningMode[InliningMode["Aggressive"] = 2] = "Aggressive";
-    return InliningMode;
-}({});
-class Dependencies {
-    constructor(verifierContext, inliningMode){
-        this.verifierContext = verifierContext;
-        this.inliningMode = inliningMode;
-        this._dependencies = [];
-    }
-    add(value) {
-        const i = this._dependencies.push(value) - 1;
-        return propertyChain(this.verifierContext, [
-            'dependencies',
-            i
-        ]);
-    }
-    addOrInline(value) {
-        if (this.inliningMode === 0) {
-            return this.add(value);
-        }
-        const expr = toLiteral(value, this.inliningMode);
-        if (expr === null) {
-            return this.add(value);
-        }
-        return expr;
-    }
-    get dependencies() {
-        return this._dependencies;
-    }
-}
-class AbstractGeneratorContextWithExprs {
-    constructor(input, output, verifierContext, dependencies){
-        this._input = input;
-        this._output = output;
-        this._verifierContext = verifierContext;
-        this._dependencies = dependencies;
-    }
-    get input() {
-        return this._input;
-    }
-    get output() {
-        return this._output;
-    }
-    get dependencies() {
-        return this._dependencies;
-    }
-    get verifierContext() {
-        return this._verifierContext;
-    }
-    *prelude() {}
-    *postlude() {}
-    *outputs(expr) {
-        yield ts.factory.createExpressionStatement(ts.factory.createAssignment(this._output, expr));
-    }
-    *report(issue, input = this.input) {
-        yield ts.factory.createExpressionStatement(ts.factory.createCallExpression(propertyChain(this.verifierContext, [
-            'reportIssue'
-        ]), undefined, [
-            issue,
-            input
-        ]));
-    }
-}
-class AbstractGeneratorContextWithExprsAndStatusVar extends AbstractGeneratorContextWithExprs {
-    *prelude() {
-        yield ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(this.statusVar, undefined, undefined, ts.factory.createNumericLiteral(standalone.ParseStatus.VALID))
-        ], ts.NodeFlags.Let));
-    }
-    constructor(...args){
-        super(...args), this.statusVar = uniqueIdentifier('status');
-    }
-}
-class FunctionalGeneratorContext extends AbstractGeneratorContextWithExprsAndStatusVar {
-    *postlude() {
-        yield ts.factory.createReturnStatement(this.statusVar);
-    }
-    *status(status, allowShortCircuiting = true) {
-        if (typeof status === 'number') {
-            if (status === standalone.ParseStatus.INVALID && allowShortCircuiting) {
-                yield ts.factory.createReturnStatement(ts.factory.createNumericLiteral(status));
-            } else {
-                yield ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(this.statusVar, ts.SyntaxKind.BarEqualsToken, ts.factory.createNumericLiteral(status)));
-            }
-        } else {
-            if (allowShortCircuiting) {
-                yield ts.factory.createIfStatement(ts.factory.createBitwiseAnd(status, ts.factory.createNumericLiteral(standalone.ParseStatus.INVALID)), ts.factory.createReturnStatement(status));
-            }
-            yield ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(this.statusVar, ts.SyntaxKind.BarEqualsToken, status));
-        }
-    }
-    withInput(expr) {
-        const x = new FunctionalGeneratorContext(expr, this.output, this.verifierContext, this.dependencies);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-var LabeledShortCircuitMode = /*#__PURE__*/ function(LabeledShortCircuitMode) {
-    LabeledShortCircuitMode[LabeledShortCircuitMode["Continue"] = 0] = "Continue";
-    LabeledShortCircuitMode[LabeledShortCircuitMode["Break"] = 1] = "Break";
-    return LabeledShortCircuitMode;
-}({});
-class LabeledBlockScopeGeneratorContext extends AbstractGeneratorContextWithExprsAndStatusVar {
-    constructor(mode, label, input, output, verifierContext, dependencies){
-        super(input, output, verifierContext, dependencies), this.mode = mode, this.label = label;
-    }
-    *status(status, allowShortCircuiting = true) {
-        yield ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(this.statusVar, ts.SyntaxKind.BarEqualsToken, typeof status === 'number' ? ts.factory.createNumericLiteral(status) : status));
-        if (allowShortCircuiting) {
-            const shortCircuit = ()=>{
-                switch(this.mode){
-                    case 1:
-                        return ts.factory.createBreakStatement(this.label);
-                    case 0:
-                        return ts.factory.createContinueStatement(this.label);
-                }
-            };
-            if (status === standalone.ParseStatus.INVALID) {
-                yield shortCircuit();
-            } else {
-                yield ts.factory.createIfStatement(ts.factory.createBitwiseAnd(this.statusVar, ts.factory.createNumericLiteral(standalone.ParseStatus.INVALID)), shortCircuit());
-            }
-        }
-    }
-    withInput(expr) {
-        const x = new LabeledBlockScopeGeneratorContext(this.mode, this.label, expr, this.output, this.verifierContext, this.dependencies);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-function toLiteral(value, mode) {
-    switch(typeof value){
-        case 'string':
-            return ts.factory.createStringLiteral(value);
-        case 'number':
-            return ts.factory.createNumericLiteral(value);
-        case 'bigint':
-            return ts.factory.createBigIntLiteral(value.toString());
-        case 'undefined':
-            return ts.factory.createIdentifier('undefined');
-        case 'boolean':
-            return value ? ts.factory.createTrue() : ts.factory.createFalse();
-        case 'object':
-            if (value === null) {
-                return ts.factory.createNull();
-            }
-            if (mode === 2) {
-                if (value instanceof RegExp) {
-                    return ts.factory.createRegularExpressionLiteral(value.toString());
-                } else if (value instanceof Map) {
-                    return ts.factory.createNewExpression(ts.factory.createIdentifier('Map'), undefined, [
-                        ts.factory.createArrayLiteralExpression([
-                            ...value.entries()
-                        ].map(([k, v])=>ts.factory.createArrayLiteralExpression([
-                                toLiteral(k, mode),
-                                toLiteral(v, mode)
-                            ])))
-                    ]);
-                } else if (value instanceof Set) {
-                    return ts.factory.createNewExpression(ts.factory.createIdentifier('Set'), undefined, [
-                        ts.factory.createArrayLiteralExpression([
-                            ...value.values()
-                        ].map((v)=>toLiteral(v, mode)))
-                    ]);
-                } else if (Array.isArray(value)) {
-                    return ts.factory.createArrayLiteralExpression(value.map((v)=>toLiteral(v, mode)));
-                } else if (value instanceof Date) {
-                    return ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), undefined, [
-                        ts.factory.createNumericLiteral(value.getTime())
-                    ]);
-                } else if (value.constructor === Object) {
-                    return ts.factory.createObjectLiteralExpression(Object.entries(value).map(([k, v])=>ts.factory.createPropertyAssignment(identifierOrStringLiteral(k), toLiteral(v, mode))));
-                } else {
-                    throw new Error(`Value cannot be inlined: ${value}`);
-                }
-            }
-            break;
-        case 'function':
-        case 'symbol':
-            if (mode === 2) {
-                throw new Error(`${typeof value === 'function' ? 'Functions' : 'Symbols'} cannot be inlined`);
-            }
-            break;
-    }
-    return null;
-}
-
-class AbstractCompiledType {
-    constructor(type){
-        this.type = type;
-    }
-}
-const registry = new Map();
-function register(zodType) {
-    return function(constructor, _context) {
-        registry.set(zodType, constructor);
-    };
-}
-function compilable(type) {
-    const typeName = type._def.typeName;
-    if (typeName === undefined) {
-        throw new TypeError('Third-party Zod types are not supported');
-    }
-    const base = registry.get(typeName);
-    if (!base) {
-        throw new TypeError(`Unimplemented Zod type \`z.${typeName}\``);
-    }
-    return new base(type);
-}
-
-// Mirrors ZodParsedType from src/helpers/util.ts
-// Mirrors getParsedType from src/helpers/util.ts
-function typeOf(data) {
-    switch(typeof data){
-        case 'undefined':
-            return "undefined";
-        case 'string':
-            return "string";
-        case 'number':
-            return isNaN(data) ? "nan" : "number";
-        case 'boolean':
-            return "boolean";
-        case 'function':
-            return "function";
-        case 'bigint':
-            return "bigint";
-        case 'symbol':
-            return "symbol";
-        case 'object':
-            if (Array.isArray(data)) {
-                return "array";
-            }
-            if (data === null) {
-                return "null";
-            }
-            if (typeof data.then === 'function' && typeof data.catch === 'function') {
-                return "promise";
-            }
-            if (data instanceof Map) {
-                return "map";
-            }
-            if (data instanceof Set) {
-                return "set";
-            }
-            if (data instanceof Date) {
-                return "date";
-            }
-            return "object";
-        default:
-            return "unknown";
-    }
-}
-function stringify(obj) {
-    return JSON.stringify(obj, (_, value)=>{
-        if (typeof value === 'bigint') {
-            return value.toString();
-        }
-        return value;
-    }, 2 /* ugggghhhhhhhh */ );
-}
-function joinValues(array, separator = ' | ') {
-    return array.map((val)=>typeof val === 'string' ? `'${val}'` : val).join(separator);
-}
-
-class ZcError extends Error {
-    get errors() {
-        return this.issues;
-    }
-    constructor(issues){
-        super(), this.issues = issues;
-        // TODO: why is this required?
-        const actualProto = new.target.prototype;
-        Object.setPrototypeOf(this, actualProto);
-        this.name = 'ZcError';
-    }
-    format(_mapper) {
-        const mapper = _mapper ?? ((issue)=>issue.message);
-        const fieldErrors = {
-            _errors: []
-        };
-        const processError = (error)=>{
-            for (const issue of error.issues){
-                if (issue.code === "invalid_union") {
-                    issue.unionErrors.map(processError);
-                } else if (issue.code === "invalid_return_type") {
-                    processError(issue.returnTypeError);
-                } else if (issue.code === "invalid_arguments") {
-                    processError(issue.argumentsError);
-                } else if (issue.path.length === 0) {
-                    fieldErrors._errors.push(mapper(issue));
-                } else {
-                    let curr = fieldErrors;
-                    let i = 0;
-                    while(i < issue.path.length){
-                        const el = issue.path[i];
-                        curr[el] ||= {
-                            _errors: []
-                        };
-                        const terminal = i === issue.path.length - 1;
-                        if (terminal) {
-                            curr[el]._errors.push(mapper(issue));
-                        }
-                        curr = curr[el];
-                        i++;
-                    }
-                }
-            }
-        };
-        processError(this);
-        return fieldErrors;
-    }
-    static create(issues) {
-        return new ZcError(issues);
-    }
-    toString() {
-        return this.message;
-    }
-    get message() {
-        return stringify(this.issues);
-    }
-    get isEmpty() {
-        return this.issues.length === 0;
-    }
-    addIssue(sub) {
-        // why not push...?
-        this.issues = [
-            ...this.issues,
-            sub
-        ];
-    }
-    addIssues(subs = []) {
-        this.issues = [
-            ...this.issues,
-            ...subs
-        ];
-    }
-    flatten(mapper = (issue)=>issue.message) {
-        const fieldErrors = {};
-        const formErrors = [];
-        for (const sub of this.issues){
-            if (sub.path.length > 0) {
-                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                fieldErrors[sub.path[0]].push(mapper(sub));
-            } else {
-                formErrors.push(mapper(sub));
-            }
-        }
-        return {
-            formErrors,
-            fieldErrors
-        };
-    }
-    get formErrors() {
-        return this.flatten(); //.formErrors?;
-    }
-}
-
-var _dec$u, _initClass$u, _AbstractCompiledType$u;
-exports.ZcAny = void 0;
-_dec$u = register(z__default.default.ZodFirstPartyTypeKind.ZodAny);
-class ZcAny extends (_AbstractCompiledType$u = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcAny, _initClass$u] } = _apply_decs_2203_r._(this, [], [
-            _dec$u
-        ], _AbstractCompiledType$u));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$u();
-    }
-}
-
-var _dec$t, _initClass$t, _AbstractCompiledType$t;
-class ArrayGeneratorContext extends LabeledBlockScopeGeneratorContext {
-    constructor(input, output, verifierContext, dependencies, parentStatusSetter){
-        super(LabeledShortCircuitMode.Continue, undefined, input, output, verifierContext, dependencies), this.parentStatusSetter = parentStatusSetter;
-    }
-    *prelude() {}
-    *status(status, allowShortCircuiting = true) {
-        yield* this.parentStatusSetter(typeof status === 'number' ? ts.factory.createNumericLiteral(status) : status);
-        if (allowShortCircuiting) {
-            if (status === standalone.ParseStatus.INVALID) {
-                yield ts.factory.createContinueStatement();
-            } else if (typeof status !== 'number') {
-                yield ts.factory.createIfStatement(ts.factory.createBitwiseAnd(status, ts.factory.createNumericLiteral(standalone.ParseStatus.INVALID)), ts.factory.createContinueStatement());
-            }
-        }
-    }
-    withInput(expr) {
-        const x = new ArrayGeneratorContext(expr, this.output, this.verifierContext, this.dependencies, this.parentStatusSetter);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-exports.ZcArray = void 0;
-_dec$t = register(z__default.default.ZodFirstPartyTypeKind.ZodArray);
-class ZcArray extends (_AbstractCompiledType$t = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcArray, _initClass$t] } = _apply_decs_2203_r._(this, [], [
-            _dec$t
-        ], _AbstractCompiledType$t));
-    }
-    compileType() {
-        return ts.factory.createArrayTypeNode(compilable(this.type._def.type).compileType());
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Array'), 'isArray'), undefined, [
-            ctx.input
-        ])), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('array'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        if (this.type._def.exactLength !== null) {
-            const value = ts.factory.createNumericLiteral(this.type._def.exactLength.value);
-            const lengthAccessor = ts.factory.createPropertyAccessExpression(ctx.input, 'length');
-            const tooBigIdent = uniqueIdentifier('tooBig');
-            const tooSmallIdent = uniqueIdentifier('tooSmall');
-            yield ts.factory.createIfStatement(ts.factory.createStrictInequality(lengthAccessor, value), ts.factory.createBlock([
-                local(tooBigIdent, ts.factory.createGreaterThan(lengthAccessor, value)),
-                local(tooSmallIdent, ts.factory.createLessThan(lengthAccessor, value)),
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createConditionalExpression(tooBigIdent, undefined, ts.factory.createStringLiteral('too_big'), undefined, ts.factory.createStringLiteral('too_small')),
-                    minimum: ts.factory.createConditionalExpression(tooSmallIdent, undefined, value, undefined, ts.factory.createIdentifier('undefined')),
-                    maximum: ts.factory.createConditionalExpression(tooBigIdent, undefined, value, undefined, ts.factory.createIdentifier('undefined')),
-                    type: ts.factory.createStringLiteral('array'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createTrue(),
-                    message: this.type._def.exactLength.message ? ts.factory.createStringLiteral(this.type._def.exactLength.message) : undefined
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        if (this.type._def.minLength !== null) {
-            yield ts.factory.createIfStatement(ts.factory.createLessThan(ts.factory.createPropertyAccessExpression(ctx.input, 'length'), ts.factory.createNumericLiteral(this.type._def.minLength.value)), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('too_small'),
-                    minimum: ts.factory.createNumericLiteral(this.type._def.minLength.value),
-                    type: ts.factory.createStringLiteral('array'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createFalse(),
-                    message: this.type._def.minLength.message ? ts.factory.createStringLiteral(this.type._def.minLength.message) : undefined
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        if (this.type._def.maxLength !== null) {
-            yield ts.factory.createIfStatement(ts.factory.createGreaterThan(ts.factory.createPropertyAccessExpression(ctx.input, 'length'), ts.factory.createNumericLiteral(this.type._def.maxLength.value)), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('too_big'),
-                    minimum: ts.factory.createNumericLiteral(this.type._def.maxLength.value),
-                    type: ts.factory.createStringLiteral('array'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createFalse(),
-                    message: this.type._def.maxLength.message ? ts.factory.createStringLiteral(this.type._def.maxLength.message) : undefined
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        const output = uniqueIdentifier('outputArray');
-        yield local(output, ts.factory.createNewExpression(ts.factory.createIdentifier('Array'), undefined, [
-            ts.factory.createPropertyAccessExpression(ctx.input, 'length')
-        ]));
-        const indexInitializer = ts.factory.createLoopVariable(true);
-        const elInitializer = uniqueIdentifier('el');
-        const elOutput = ts.factory.createElementAccessExpression(output, indexInitializer);
-        const childCtx = new ArrayGeneratorContext(elInitializer, elOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        yield ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([
-                ts.factory.createBindingElement(undefined, undefined, indexInitializer),
-                ts.factory.createBindingElement(undefined, undefined, elInitializer)
-            ]))
-        ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ctx.input, 'entries'), undefined, undefined), ts.factory.createBlock([
-            ...childCtx.prelude(),
-            ...compilable(this.type._def.type).compileParser(childCtx, path.push(indexInitializer)),
-            ...childCtx.postlude()
-        ]));
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$t();
-    }
-}
-
-var _dec$s, _initClass$s, _AbstractCompiledType$s;
-exports.ZcBigInt = void 0;
-_dec$s = register(z__default.default.ZodFirstPartyTypeKind.ZodBigInt);
-class ZcBigInt extends (_AbstractCompiledType$s = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcBigInt, _initClass$s] } = _apply_decs_2203_r._(this, [], [
-            _dec$s
-        ], _AbstractCompiledType$s));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword);
-    }
-    *compileParser(ctx, path) {
-        let input = ctx.input;
-        if (this.type._def.coerce) {
-            const ident = uniqueIdentifier('coercedInput');
-            yield local(ident, undefined, true);
-            input = ident;
-            yield ts.factory.createTryStatement(ts.factory.createBlock([
-                ts.factory.createExpressionStatement(ts.factory.createAssignment(ident, ts.factory.createCallExpression(ts.factory.createIdentifier('BigInt'), undefined, [
-                    ctx.input
-                ])))
-            ], true), ts.factory.createCatchClause(uniqueIdentifier('e'), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('invalid_type'),
-                    expected: ts.factory.createStringLiteral('bigint'),
-                    received: callHelper(ctx.verifierContext, 'typeOf', input)
-                }), input),
-                // hopefully this causes a short circuit and the rest of the body doesn't get executed...
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ], true)), undefined);
-        }
-        let stmt = ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(input), ts.factory.createStringLiteral('bigint')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('bigint'),
-                received: callHelper(ctx.verifierContext, 'typeOf', input)
-            }), input),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        const checkStmts = [];
-        for (const check of this.type._def.checks){
-            switch(check.kind){
-                case 'min':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory[check.inclusive ? 'createLessThan' : 'createLessThanEquals'](input, ts.factory.createBigIntLiteral(check.value.toString())), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_small'),
-                            minimum: ts.factory.createBigIntLiteral(check.value.toString()),
-                            type: ts.factory.createStringLiteral('bigint'),
-                            inclusive: check.inclusive ? ts.factory.createTrue() : ts.factory.createFalse(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'max':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory[check.inclusive ? 'createGreaterThan' : 'createGreaterThanEquals'](input, ts.factory.createBigIntLiteral(check.value.toString())), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_big'),
-                            minimum: ts.factory.createBigIntLiteral(check.value.toString()),
-                            type: ts.factory.createStringLiteral('bigint'),
-                            inclusive: check.inclusive ? ts.factory.createTrue() : ts.factory.createFalse(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'multipleOf':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createModulo(input, ts.factory.createBigIntLiteral(check.value.toString())), ts.factory.createBigIntLiteral('0')), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('not_multiple_of'),
-                            multipleOf: ts.factory.createBigIntLiteral(check.value.toString()),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                default:
-                    throw new Error(`Unsupported ZcBigInt check: ${check}`);
-            }
-        }
-        if (checkStmts.length === 0) {
-            yield stmt;
-        } else {
-            stmt = ts.factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, ts.factory.createBlock([
-                ...checkStmts
-            ], true));
-            yield stmt;
-        }
-        yield* ctx.outputs(input);
-    }
-    static{
-        _initClass$s();
-    }
-}
-
-var _dec$r, _initClass$r, _AbstractCompiledType$r;
-exports.ZcBoolean = void 0;
-_dec$r = register(z__default.default.ZodFirstPartyTypeKind.ZodBoolean);
-class ZcBoolean extends (_AbstractCompiledType$r = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcBoolean, _initClass$r] } = _apply_decs_2203_r._(this, [], [
-            _dec$r
-        ], _AbstractCompiledType$r));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-    }
-    *compileParser(ctx, path) {
-        let input = ctx.input;
-        if (this.type._def.coerce) {
-            const ident = uniqueIdentifier('coercedInput');
-            yield local(ident, ts.factory.createCallExpression(ts.factory.createIdentifier('Boolean'), [], [
-                ctx.input
-            ]), false);
-            input = ident;
-        }
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(input), ts.factory.createStringLiteral('boolean')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('boolean'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            }), input),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$r();
-    }
-}
-
-var _dec$q, _initClass$q, _AbstractCompiledType$q;
-exports.ZcBranded = void 0;
-_dec$q = register(z__default.default.ZodFirstPartyTypeKind.ZodBranded);
-class ZcBranded extends (_AbstractCompiledType$q = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcBranded, _initClass$q] } = _apply_decs_2203_r._(this, [], [
-            _dec$q
-        ], _AbstractCompiledType$q));
-    }
-    compileType() {
-        return compilable(this.type._def.type).compileType();
-    }
-    *compileParser(ctx, path) {
-        yield* compilable(this.type._def.type).compileParser(ctx, path);
-    }
-    static{
-        _initClass$q();
-    }
-}
-
-var _dec$p, _initClass$p, _AbstractCompiledType$p;
-class CatchGeneratorContext extends LabeledBlockScopeGeneratorContext {
-    constructor(label, input, output, verifierContext, dependencies, statusVar){
-        super(LabeledShortCircuitMode.Break, label, input, output, verifierContext, dependencies);
-        this.statusVar = statusVar;
-    }
-    *prelude() {}
-    withInput(expr) {
-        const x = new CatchGeneratorContext(this.label, expr, this.output, this.verifierContext, this.dependencies, this.statusVar);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-exports.ZcCatch = void 0;
-_dec$p = register(z__default.default.ZodFirstPartyTypeKind.ZodCatch);
-class ZcCatch extends (_AbstractCompiledType$p = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcCatch, _initClass$p] } = _apply_decs_2203_r._(this, [], [
-            _dec$p
-        ], _AbstractCompiledType$p));
-    }
-    compileType() {
-        return compilable(this.type._def.innerType).compileType();
-    }
-    *compileParser(ctx, path) {
-        const caughtStatus = uniqueIdentifier('caughtStatus');
-        yield local(caughtStatus, ts.factory.createNumericLiteral(standalone.ParseStatus.VALID), true);
-        const output = uniqueIdentifier('caughtOutput');
-        yield local(output, undefined, true);
-        const verifierCtxVar = uniqueIdentifier('variantCtx');
-        yield local(verifierCtxVar, ts.factory.createObjectLiteralExpression([
-            ts.factory.createSpreadAssignment(ctx.verifierContext),
-            ts.factory.createPropertyAssignment('issues', ts.factory.createArrayLiteralExpression())
-        ], true));
-        const label = uniqueIdentifier('catch');
-        const childCtx = new CatchGeneratorContext(label, ctx.input, output, verifierCtxVar, ctx.dependencies, caughtStatus);
-        const catchValue = ctx.dependencies.addOrInline(this.type._def.catchValue(null));
-        yield ts.factory.createLabeledStatement(label, ts.factory.createBlock([
-            ...childCtx.prelude(),
-            ...compilable(this.type._def.innerType).compileParser(childCtx, path),
-            ...childCtx.postlude()
-        ]));
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(caughtStatus, ts.factory.createNumericLiteral(standalone.ParseStatus.VALID)), ts.factory.createBlock([
-            ...ctx.outputs(catchValue)
-        ], true), ts.factory.createBlock([
-            ...ctx.outputs(output)
-        ], true));
-    }
-    static{
-        _initClass$p();
-    }
-}
-
-var _dec$o, _initClass$o, _AbstractCompiledType$o;
-exports.ZcDate = void 0;
-_dec$o = register(z__default.default.ZodFirstPartyTypeKind.ZodDate);
-class ZcDate extends (_AbstractCompiledType$o = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcDate, _initClass$o] } = _apply_decs_2203_r._(this, [], [
-            _dec$o
-        ], _AbstractCompiledType$o));
-    }
-    compileType() {
-        return ts.factory.createTypeReferenceNode('Date');
-    }
-    *compileParser(ctx, path) {
-        let input = ctx.input;
-        if (this.type._def.coerce) {
-            const ident = uniqueIdentifier('coercedInput');
-            yield local(ident, ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [
-                ctx.input
-            ]), false);
-            input = ident;
-        }
-        let stmt = ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createBinaryExpression(input, ts.SyntaxKind.InstanceOfKeyword, ts.factory.createIdentifier('Date'))), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('date'),
-                received: callHelper(ctx.verifierContext, 'typeOf', input)
-            }), input),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        const timeVar = uniqueIdentifier('time');
-        const checkStmts = [
-            local(timeVar, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(input, 'getTime'), undefined, [])),
-            ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier('isNaN'), undefined, [
-                timeVar
-            ]), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('invalid_date')
-                }), input),
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ], true))
-        ];
-        for (const check of this.type._def.checks){
-            switch(check.kind){
-                case 'min':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createLessThan(timeVar, ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_small'),
-                            minimum: ts.factory.createNumericLiteral(check.value),
-                            type: ts.factory.createStringLiteral('date'),
-                            inclusive: ts.factory.createTrue(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'max':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createGreaterThan(timeVar, ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_big'),
-                            minimum: ts.factory.createNumericLiteral(check.value),
-                            type: ts.factory.createStringLiteral('date'),
-                            inclusive: ts.factory.createTrue(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                default:
-                    throw new Error(`Unsupported ZcDate check: ${check}`);
-            }
-        }
-        yield ts.factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, ts.factory.createBlock([
-            ...checkStmts
-        ], true));
-        yield* ctx.outputs(input);
-    }
-    static{
-        _initClass$o();
-    }
-}
-
-var _dec$n, _initClass$n, _AbstractCompiledType$n;
-exports.ZcDefault = void 0;
-_dec$n = register(z__default.default.ZodFirstPartyTypeKind.ZodDefault);
-class ZcDefault extends (_AbstractCompiledType$n = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcDefault, _initClass$n] } = _apply_decs_2203_r._(this, [], [
-            _dec$n
-        ], _AbstractCompiledType$n));
-    }
-    compileType() {
-        return compilable(this.type._def.innerType).compileType();
-    }
-    *compileParser(ctx, path) {
-        const newInput = uniqueIdentifier('defaultInput');
-        yield local(newInput, ctx.input, true);
-        const defaultValue = ctx.dependencies.addOrInline(this.type._def.defaultValue());
-        yield ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createTypeOfExpression(newInput), ts.factory.createStringLiteral('undefined')), ts.factory.createBlock([
-            ts.factory.createExpressionStatement(ts.factory.createAssignment(newInput, defaultValue))
-        ], true));
-        yield* compilable(this.type._def.innerType).compileParser(ctx.withInput(newInput), path);
-    }
-    static{
-        _initClass$n();
-    }
-}
-
-var _dec$m, _initClass$m, _AbstractCompiledType$m;
-class ObjectGeneratorContext extends LabeledBlockScopeGeneratorContext {
-    constructor(label, input, output, verifierContext, dependencies, parentStatusSetter){
-        super(LabeledShortCircuitMode.Break, label, input, output, verifierContext, dependencies), this.parentStatusSetter = parentStatusSetter;
-    }
-    *prelude() {}
-    *status(status, allowShortCircuiting = true) {
-        yield* this.parentStatusSetter(typeof status === 'number' ? ts.factory.createNumericLiteral(status) : status);
-        if (allowShortCircuiting) {
-            if (status === standalone.ParseStatus.INVALID) {
-                yield ts.factory.createBreakStatement(this.label);
-            } else if (typeof status !== 'number') {
-                yield ts.factory.createIfStatement(ts.factory.createBitwiseAnd(status, ts.factory.createNumericLiteral(standalone.ParseStatus.INVALID)), ts.factory.createBreakStatement(this.label));
-            }
-        }
-    }
-    withInput(expr) {
-        const x = new ObjectGeneratorContext(this.label, expr, this.output, this.verifierContext, this.dependencies, this.parentStatusSetter);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-exports.ZcObject = void 0;
-_dec$m = register(z__default.default.ZodFirstPartyTypeKind.ZodObject);
-class ZcObject extends (_AbstractCompiledType$m = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcObject, _initClass$m] } = _apply_decs_2203_r._(this, [], [
-            _dec$m
-        ], _AbstractCompiledType$m));
-    }
-    compileType() {
-        return ts.factory.createTypeLiteralNode(Object.entries(this.type._def.shape()).map(([key, value])=>{
-            const type = compilable(value);
-            const isOptional = value._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodOptional || value.isOptional();
-            const node = ts.factory.createPropertySignature(undefined, identifierOrStringLiteral(key), isOptional && value._def.typeName !== z__default.default.ZodFirstPartyTypeKind.ZodDefault ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined, type.compileType());
-            if (value.description) {
-                ts__default.default.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `* ${value.description} `, true);
-            }
-            return node;
-        }));
-    }
-    *compileParser(ctx, path) {
-        if (!this.canSkipTypeCheck) {
-            const typeIdentifier = uniqueIdentifier('type');
-            yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
-            yield ts.factory.createIfStatement(ts.factory.createStrictInequality(typeIdentifier, ts.factory.createStringLiteral('object')), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('invalid_type'),
-                    expected: ts.factory.createStringLiteral('object'),
-                    received: typeIdentifier
-                })),
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ], true));
-        }
-        const shape = this.type._def.shape();
-        // TODO: catchall/passthrough/strict
-        // const shapeKeysIdent = uniqueIdentifier('shapeKeys');
-        // yield local(
-        // 	shapeKeysIdent,
-        // 	factory.createNewExpression(
-        // 		factory.createIdentifier('Set'),
-        // 		[],
-        // 		[ factory.createArrayLiteralExpression(Object.keys(shape).map(key => factory.createStringLiteral(key))) ]
-        // 	)
-        // );
-        const output = uniqueIdentifier('outputObject');
-        yield local(output, ts.factory.createObjectLiteralExpression());
-        for (const [i, [key, value]] of Object.entries(shape).entries()){
-            const label = uniqueIdentifier(`prop${i}`);
-            const inputExpr = propertyChain(ctx.input, [
-                key
-            ]);
-            const outputExpr = propertyChain(output, [
-                key
-            ]);
-            const childCtx = new ObjectGeneratorContext(label, inputExpr, outputExpr, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-            yield ts.factory.createLabeledStatement(label, ts.factory.createBlock([
-                ...compilable(value).compileParser(childCtx, path.push(key))
-            ]));
-        }
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$m();
-    }
-    constructor(...args){
-        super(...args), // In the case of discriminated unions, we already check that the type is an object before passing off parsing
-        // to a ZcObject.
-        this.canSkipTypeCheck = false;
-    }
-}
-
-var _dec$l, _initClass$l, _AbstractCompiledType$l;
-exports.ZcDiscriminatedUnion = void 0;
-_dec$l = register(z__default.default.ZodFirstPartyTypeKind.ZodDiscriminatedUnion);
-class ZcDiscriminatedUnion extends (_AbstractCompiledType$l = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcDiscriminatedUnion, _initClass$l] } = _apply_decs_2203_r._(this, [], [
-            _dec$l
-        ], _AbstractCompiledType$l));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode(this.type._def.options.map((ty)=>compilable(ty).compileType()));
-    }
-    *compileParser(ctx, path) {
-        const typeIdentifier = uniqueIdentifier('type');
-        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(typeIdentifier, ts.factory.createStringLiteral('object')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('object'),
-                received: typeIdentifier
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield ts.factory.createSwitchStatement(propertyChain(ctx.input, [
-            this.type._def.discriminator
-        ]), ts.factory.createCaseBlock([
-            ...[
-                ...this.type._def.optionsMap.entries()
-            ].map(([discriminator, zodTy])=>{
-                const ty = compilable(zodTy);
-                if (ty instanceof exports.ZcObject) {
-                    // We've already checked that the input is an object.
-                    ty.canSkipTypeCheck = true;
-                }
-                return ts.factory.createCaseClause(ctx.dependencies.addOrInline(discriminator), [
-                    ...ty.compileParser(ctx, path),
-                    ts.factory.createBreakStatement()
-                ]);
-            }),
-            ts.factory.createDefaultClause([
-                ...ctx.report(objectLiteral({
-                    path: path.push(this.type._def.discriminator).serialize(),
-                    code: ts.factory.createStringLiteral('invalid_union_discriminator'),
-                    options: ctx.dependencies.add(Array.from(this.type._def.optionsMap.keys()))
-                })),
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ])
-        ]));
-    }
-    static{
-        _initClass$l();
-    }
-}
-
-var _dec$k, _initClass$k, _AbstractCompiledType$k;
-exports.ZcEnum = void 0;
-_dec$k = register(z__default.default.ZodFirstPartyTypeKind.ZodEnum);
-class ZcEnum extends (_AbstractCompiledType$k = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcEnum, _initClass$k] } = _apply_decs_2203_r._(this, [], [
-            _dec$k
-        ], _AbstractCompiledType$k));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode(this.type._def.values.map((ty)=>ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ty))));
-    }
-    *compileParser(ctx, path) {
-        const clauses = this.type._def.values.map((value)=>ts.factory.createCaseClause(ts.factory.createStringLiteral(value), []));
-        const lastClause = clauses[clauses.length - 1];
-        clauses[clauses.length - 1] = ts.factory.updateCaseClause(lastClause, lastClause.expression, [
-            ...ctx.outputs(ctx.input),
-            ts.factory.createBreakStatement()
-        ]);
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('string')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral(this.type._def.values.map((value)=>`"${value}"`).join(' | ')),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true), ts.factory.createBlock([
-            ts.factory.createSwitchStatement(ctx.input, ts.factory.createCaseBlock([
-                ...clauses,
-                ts.factory.createDefaultClause([
-                    ...ctx.report(objectLiteral({
-                        path: path.serialize(),
-                        code: ts.factory.createStringLiteral('invalid_enum_value'),
-                        options: ts.factory.createArrayLiteralExpression(this.type._def.values.map((value)=>ts.factory.createStringLiteral(value))),
-                        received: ctx.input
-                    })),
-                    ...ctx.status(standalone.ParseStatus.INVALID)
-                ])
-            ]))
-        ], true));
-    }
-    static{
-        _initClass$k();
-    }
-}
-
-var _dec$j, _initClass$j, _AbstractCompiledType$j;
-class IntersectionGeneratorContext extends LabeledBlockScopeGeneratorContext {
-    constructor(parentLabel, label, input, output, verifierContext, dependencies, parentStatusSetter){
-        super(LabeledShortCircuitMode.Break, label, input, output, verifierContext, dependencies), this.parentLabel = parentLabel, this.parentStatusSetter = parentStatusSetter;
-    }
-    *status(status, allowShortCircuiting = true) {
-        yield* this.parentStatusSetter(typeof status === 'number' ? ts.factory.createNumericLiteral(status) : status);
-        if (allowShortCircuiting) {
-            if (status === standalone.ParseStatus.INVALID) {
-                yield ts.factory.createBreakStatement(this.label);
-            } else if (typeof status !== 'number') {
-                yield ts.factory.createIfStatement(ts.factory.createBitwiseAnd(status, ts.factory.createNumericLiteral(standalone.ParseStatus.INVALID)), ts.factory.createBreakStatement(this.label));
-            }
-        }
-    }
-    withInput(expr) {
-        const x = new IntersectionGeneratorContext(this.parentLabel, this.label, expr, this.output, this.verifierContext, this.dependencies, this.parentStatusSetter);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-exports.ZcIntersection = void 0;
-_dec$j = register(z__default.default.ZodFirstPartyTypeKind.ZodIntersection);
-class ZcIntersection extends (_AbstractCompiledType$j = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcIntersection, _initClass$j] } = _apply_decs_2203_r._(this, [], [
-            _dec$j
-        ], _AbstractCompiledType$j));
-    }
-    compileType() {
-        return ts.factory.createIntersectionTypeNode([
-            compilable(this.type._def.left).compileType(),
-            compilable(this.type._def.right).compileType()
-        ]);
-    }
-    *compileParser(ctx, path) {
-        const mergeOutput = uniqueIdentifier('intersectionOutput');
-        const outputA = uniqueIdentifier('outputA');
-        const outputB = uniqueIdentifier('outputB');
-        const label = uniqueIdentifier('intersection');
-        yield ts.factory.createLabeledStatement(label, ts.factory.createBlock([
-            ...this._generateSide(ctx, path, label, 'left', outputA),
-            ...this._generateSide(ctx, path, label, 'right', outputB),
-            // TODO: We only break one side when parsing fails so that the other can continue to parse; this causes `mergeValues`
-            // (and probably the `invalid_intersection_types` issue) to always be called if either side fails. Zod does not do this.
-            // We need some way to short circuit here if the status is invalid; context should allow inspecting status instead of
-            // being setter-only.
-            local(mergeOutput, callHelper(ctx.verifierContext, 'mergeValues', outputA, outputB)),
-            ts.factory.createIfStatement(ts.factory.createPropertyAccessExpression(mergeOutput, 'valid'), ts.factory.createBlock([
-                ...ctx.outputs(ts.factory.createPropertyAccessExpression(mergeOutput, 'data'))
-            ], true), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('invalid_intersection_types')
-                })),
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ]))
-        ]));
-    }
-    *_generateSide(ctx, path, parentLabel, side, output) {
-        const name = side === 'left' ? 'A' : 'B';
-        const label = uniqueIdentifier(`type${name}`);
-        yield local(output, undefined, true);
-        const childCtx = new IntersectionGeneratorContext(parentLabel, label, ctx.input, output, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        yield ts.factory.createLabeledStatement(label, ts.factory.createBlock([
-            ...compilable(this.type._def[side]).compileParser(childCtx, path)
-        ]));
-    }
-    static{
-        _initClass$j();
-    }
-}
-
-var _dec$i, _initClass$i, _AbstractCompiledType$i;
-exports.ZcLiteral = void 0;
-_dec$i = register(z__default.default.ZodFirstPartyTypeKind.ZodLiteral);
-class ZcLiteral extends (_AbstractCompiledType$i = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcLiteral, _initClass$i] } = _apply_decs_2203_r._(this, [], [
-            _dec$i
-        ], _AbstractCompiledType$i));
-    }
-    compileType() {
-        const value = this.type._def.value;
-        let n;
-        switch(typeof value){
-            case 'string':
-                n = ts.factory.createStringLiteral(value);
-                break;
-            case 'number':
-                n = ts.factory.createNumericLiteral(value);
-                break;
-            case 'bigint':
-                n = ts.factory.createBigIntLiteral(value.toString());
-                break;
-            case 'undefined':
-                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
-            case 'boolean':
-                n = value ? ts.factory.createTrue() : ts.factory.createFalse();
-            case 'object':
-                if (value === null) {
-                    n = ts.factory.createNull();
-                }
-            // fallthrough
-            default:
-                throw new Error(`\`zc.ZcLiteral\` only supports primitives (string, number, BigInt, boolean, null, or undefined); got '${typeOf(value)}'`);
-        }
-        return ts.factory.createLiteralTypeNode(n);
-    }
-    *compileParser(ctx, path) {
-        const value = ctx.dependencies.addOrInline(this.type._def.value);
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ctx.input, value), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_literal'),
-                expected: value,
-                received: ctx.input
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$i();
-    }
-}
-
-var _dec$h, _initClass$h, _AbstractCompiledType$h;
-exports.ZcMap = void 0;
-_dec$h = register(z__default.default.ZodFirstPartyTypeKind.ZodMap);
-class ZcMap extends (_AbstractCompiledType$h = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcMap, _initClass$h] } = _apply_decs_2203_r._(this, [], [
-            _dec$h
-        ], _AbstractCompiledType$h));
-    }
-    compileType() {
-        const [k, v] = [
-            compilable(this.type._def.keyType),
-            compilable(this.type._def.valueType)
-        ];
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Map'), [
-            k.compileType(),
-            v.compileType()
-        ]);
-    }
-    *compileParser(ctx, path) {
-        const typeIdentifier = uniqueIdentifier('type');
-        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(typeIdentifier, ts.factory.createStringLiteral('map')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('map'),
-                received: typeIdentifier
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        const output = uniqueIdentifier('outputMap');
-        yield local(output, ts.factory.createNewExpression(ts.factory.createIdentifier('Map'), undefined, []));
-        const keyLabel = uniqueIdentifier('parseKey');
-        const keyInput = uniqueIdentifier('key');
-        const keyOutput = uniqueIdentifier('keyOut');
-        const valueLabel = uniqueIdentifier('parseValue');
-        const valueInput = uniqueIdentifier('value');
-        const valueOutput = uniqueIdentifier('valueOut');
-        const keyCtx = new ObjectGeneratorContext(keyLabel, keyInput, keyOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        const valueCtx = new ObjectGeneratorContext(valueLabel, valueInput, valueOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        yield ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([
-                ts.factory.createBindingElement(undefined, undefined, keyInput),
-                ts.factory.createBindingElement(undefined, undefined, valueInput)
-            ]))
-        ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ctx.input, 'entries'), undefined, []), ts.factory.createBlock([
-            local(keyOutput, keyInput, true),
-            local(valueOutput, undefined, true),
-            ts.factory.createLabeledStatement(keyLabel, ts.factory.createBlock([
-                ...compilable(this.type._def.keyType).compileParser(keyCtx, path)
-            ])),
-            ts.factory.createLabeledStatement(valueLabel, ts.factory.createBlock([
-                ...compilable(this.type._def.valueType).compileParser(valueCtx, path.push(keyOutput))
-            ])),
-            ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(output, 'set'), undefined, [
-                keyOutput,
-                valueOutput
-            ]))
-        ]));
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$h();
-    }
-}
-
-var _dec$g, _initClass$g, _AbstractCompiledType$g;
-exports.ZcNaN = void 0;
-_dec$g = register(z__default.default.ZodFirstPartyTypeKind.ZodNaN);
-class ZcNaN extends (_AbstractCompiledType$g = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNaN, _initClass$g] } = _apply_decs_2203_r._(this, [], [
-            _dec$g
-        ], _AbstractCompiledType$g));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createLogicalOr(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('number')), ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createIdentifier('isNaN'), undefined, [
-            ctx.input
-        ]))), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('nan'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$g();
-    }
-}
-
-var _dec$f, _initClass$f, _AbstractCompiledType$f;
-function getValidEnumValues(obj) {
-    const validKeys = Object.keys(obj).filter((k)=>typeof obj[obj[k]] !== 'number');
-    const filtered = {};
-    for (const k of validKeys){
-        filtered[k] = obj[k];
-    }
-    return [
-        ...new Set(Object.values(filtered))
-    ];
-}
-exports.ZcNativeEnum = void 0;
-_dec$f = register(z__default.default.ZodFirstPartyTypeKind.ZodNativeEnum);
-class ZcNativeEnum extends (_AbstractCompiledType$f = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNativeEnum, _initClass$f] } = _apply_decs_2203_r._(this, [], [
-            _dec$f
-        ], _AbstractCompiledType$f));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode(getValidEnumValues(this.type._def.values).map((value)=>ts.factory.createLiteralTypeNode(typeof value === 'string' ? ts.factory.createStringLiteral(value) : ts.factory.createNumericLiteral(value))));
-    }
-    *compileParser(ctx, path) {
-        const values = getValidEnumValues(this.type._def.values);
-        const clauses = values.map((value)=>ts.factory.createCaseClause(typeof value === 'string' ? ts.factory.createStringLiteral(value) : ts.factory.createNumericLiteral(value), []));
-        const lastClause = clauses[clauses.length - 1];
-        clauses[clauses.length - 1] = ts.factory.updateCaseClause(lastClause, lastClause.expression, [
-            ...ctx.outputs(ctx.input),
-            ts.factory.createBreakStatement()
-        ]);
-        yield ts.factory.createIfStatement(ts.factory.createLogicalAnd(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('string')), ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('number'))), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral(joinValues(values)),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true), ts.factory.createBlock([
-            ts.factory.createSwitchStatement(ctx.input, ts.factory.createCaseBlock([
-                ...clauses,
-                ts.factory.createDefaultClause([
-                    ...ctx.report(objectLiteral({
-                        path: path.serialize(),
-                        code: ts.factory.createStringLiteral('invalid_enum_value'),
-                        options: ts.factory.createArrayLiteralExpression(values.map((value)=>typeof value === 'string' ? ts.factory.createStringLiteral(value) : ts.factory.createNumericLiteral(value))),
-                        received: ctx.input
-                    })),
-                    ...ctx.status(standalone.ParseStatus.INVALID)
-                ])
-            ]))
-        ], true));
-    }
-    static{
-        _initClass$f();
-    }
-}
-
-var _dec$e, _initClass$e, _AbstractCompiledType$e;
-exports.ZcNever = void 0;
-_dec$e = register(z__default.default.ZodFirstPartyTypeKind.ZodNever);
-class ZcNever extends (_AbstractCompiledType$e = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNever, _initClass$e] } = _apply_decs_2203_r._(this, [], [
-            _dec$e
-        ], _AbstractCompiledType$e));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield* ctx.report(objectLiteral({
-            path: path.serialize(),
-            code: ts.factory.createStringLiteral('invalid_type'),
-            expected: ts.factory.createStringLiteral('never'),
-            received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-        }));
-        yield* ctx.status(standalone.ParseStatus.INVALID);
-    }
-    static{
-        _initClass$e();
-    }
-}
-
-var _dec$d, _initClass$d, _AbstractCompiledType$d;
-exports.ZcNull = void 0;
-_dec$d = register(z__default.default.ZodFirstPartyTypeKind.ZodNull);
-class ZcNull extends (_AbstractCompiledType$d = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNull, _initClass$d] } = _apply_decs_2203_r._(this, [], [
-            _dec$d
-        ], _AbstractCompiledType$d));
-    }
-    compileType() {
-        return ts.factory.createLiteralTypeNode(ts.factory.createNull());
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ctx.input, ts.factory.createNull()), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('null'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$d();
-    }
-}
-
-var _dec$c, _initClass$c, _AbstractCompiledType$c;
-exports.ZcNullable = void 0;
-_dec$c = register(z__default.default.ZodFirstPartyTypeKind.ZodNullable);
-class ZcNullable extends (_AbstractCompiledType$c = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNullable, _initClass$c] } = _apply_decs_2203_r._(this, [], [
-            _dec$c
-        ], _AbstractCompiledType$c));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode([
-            compilable(this.type._def.innerType).compileType(),
-            ts.factory.createLiteralTypeNode(ts.factory.createNull())
-        ]);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictEquality(ctx.input, ts.factory.createNull()), ts.factory.createBlock([
-            ...ctx.outputs(ts.factory.createNull())
-        ], true), ts.factory.createBlock([
-            ...compilable(this.type._def.innerType).compileParser(ctx, path)
-        ], true));
-    }
-    static{
-        _initClass$c();
-    }
-}
-
-var _dec$b, _initClass$b, _AbstractCompiledType$b;
-exports.ZcNumber = void 0;
-_dec$b = register(z__default.default.ZodFirstPartyTypeKind.ZodNumber);
-class ZcNumber extends (_AbstractCompiledType$b = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcNumber, _initClass$b] } = _apply_decs_2203_r._(this, [], [
-            _dec$b
-        ], _AbstractCompiledType$b));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-    }
-    *compileParser(ctx, path) {
-        let input = ctx.input;
-        if (this.type._def.coerce) {
-            const ident = uniqueIdentifier('coercedInput');
-            yield local(ident, ts.factory.createCallExpression(ts.factory.createIdentifier('Number'), [], [
-                ctx.input
-            ]), false);
-            input = ident;
-        }
-        let stmt = ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(input), ts.factory.createStringLiteral('number')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('number'),
-                received: callHelper(ctx.verifierContext, 'typeOf', input)
-            }), input),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        const checkStmts = [];
-        for (const check of this.type._def.checks){
-            switch(check.kind){
-                case 'min':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory[check.inclusive ? 'createLessThan' : 'createLessThanEquals'](input, ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_small'),
-                            minimum: ts.factory.createNumericLiteral(check.value),
-                            type: ts.factory.createStringLiteral('number'),
-                            inclusive: check.inclusive ? ts.factory.createTrue() : ts.factory.createFalse(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'max':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory[check.inclusive ? 'createGreaterThan' : 'createGreaterThanEquals'](input, ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('too_big'),
-                            minimum: ts.factory.createNumericLiteral(check.value),
-                            type: ts.factory.createStringLiteral('number'),
-                            inclusive: check.inclusive ? ts.factory.createTrue() : ts.factory.createFalse(),
-                            exact: ts.factory.createFalse(),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'int':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Number'), 'isInteger'), undefined, [
-                        input
-                    ])), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('invalid_type'),
-                            expected: ts.factory.createStringLiteral('integer'),
-                            received: ts.factory.createStringLiteral('float'),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'finite':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Number'), 'isFinite'), undefined, [
-                        input
-                    ])), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('not_finite'),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                case 'multipleOf':
-                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createStrictInequality(callHelper(ctx.verifierContext, 'floatSafeRemainder', input, ts.factory.createNumericLiteral(check.value)), ts.factory.createNumericLiteral(0)), ts.factory.createBlock([
-                        ...ctx.report(objectLiteral({
-                            path: path.serialize(),
-                            code: ts.factory.createStringLiteral('not_multiple_of'),
-                            multipleOf: ts.factory.createNumericLiteral(check.value),
-                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                        }), input),
-                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                    ], true)));
-                    break;
-                default:
-                    throw new Error(`Unsupported ZcNumber check: ${check}`);
-            }
-        }
-        if (checkStmts.length === 0) {
-            yield stmt;
-        } else {
-            stmt = ts.factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, ts.factory.createBlock([
-                ...checkStmts
-            ], true));
-            yield stmt;
-        }
-        yield* ctx.outputs(input);
-    }
-    static{
-        _initClass$b();
-    }
-}
-
-var _dec$a, _initClass$a, _AbstractCompiledType$a;
-exports.ZcOptional = void 0;
-_dec$a = register(z__default.default.ZodFirstPartyTypeKind.ZodOptional);
-class ZcOptional extends (_AbstractCompiledType$a = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcOptional, _initClass$a] } = _apply_decs_2203_r._(this, [], [
-            _dec$a
-        ], _AbstractCompiledType$a));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode([
-            compilable(this.type._def.innerType).compileType(),
-            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
-        ]);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('undefined')), ts.factory.createBlock([
-            ...ctx.outputs(ts.factory.createIdentifier('undefined'))
-        ], true), ts.factory.createBlock([
-            ...compilable(this.type._def.innerType).compileParser(ctx, path)
-        ], true));
-    }
-    static{
-        _initClass$a();
-    }
-}
-
-var _dec$9, _initClass$9, _AbstractCompiledType$9;
-class ReadonlyGeneratorContext {
-    constructor(ctx){
-        this.ctx = ctx;
-    }
-    get dependencies() {
-        return this.ctx.dependencies;
-    }
-    get input() {
-        return this.ctx.input;
-    }
-    get verifierContext() {
-        return this.ctx.verifierContext;
-    }
-    withInput(expr) {
-        return new ReadonlyGeneratorContext(this.ctx.withInput(expr));
-    }
-    prelude() {
-        return this.ctx.prelude();
-    }
-    postlude() {
-        return this.ctx.postlude();
-    }
-    report(expr) {
-        return this.ctx.report(expr);
-    }
-    status(status, allowShortCircuiting) {
-        return this.ctx.status(status, allowShortCircuiting);
-    }
-    *outputs(expr) {
-        yield* this.ctx.outputs(ts.factory.createCallExpression(propertyChain(ts.factory.createIdentifier('Object'), [
-            'freeze'
-        ]), undefined, [
-            expr
-        ]));
-    }
-}
-exports.ZcReadonly = void 0;
-_dec$9 = register(z__default.default.ZodFirstPartyTypeKind.ZodReadonly);
-class ZcReadonly extends (_AbstractCompiledType$9 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcReadonly, _initClass$9] } = _apply_decs_2203_r._(this, [], [
-            _dec$9
-        ], _AbstractCompiledType$9));
-    }
-    compileType() {
-        let innerType = compilable(this.type._def.innerType).compileType();
-        if (ts__default.default.isArrayTypeNode(innerType)) {
-            return ts.factory.createTypeOperatorNode(ts__default.default.SyntaxKind.ReadonlyKeyword, innerType);
-        } else if (ts__default.default.isObjectLiteralExpression(innerType) || ts__default.default.isUnionTypeNode(innerType) || ts__default.default.isIntersectionTypeNode(innerType)) {
-            return ts.factory.createTypeReferenceNode('Readonly', [
-                innerType
-            ]);
-        } else if (ts__default.default.isTypeReferenceNode(innerType) && ts__default.default.isIdentifier(innerType.typeName)) {
-            switch(innerType.typeName.text){
-                case 'Map':
-                case 'Set':
-                    innerType = ts.factory.updateTypeReferenceNode(innerType, ts.factory.createIdentifier(`Readonly${innerType.typeName.text}`), innerType.typeArguments);
-                    break;
-                case 'Record':
-                    innerType = ts.factory.createTypeReferenceNode('Readonly', [
-                        innerType
-                    ]);
-                    break;
-            }
-        }
-        return innerType;
-    }
-    *compileParser(ctx, path) {
-        yield* compilable(this.type._def.innerType).compileParser(new ReadonlyGeneratorContext(ctx), path);
-    }
-    static{
-        _initClass$9();
-    }
-}
-
-var _dec$8, _initClass$8, _AbstractCompiledType$8;
-exports.ZcRecord = void 0;
-_dec$8 = register(z__default.default.ZodFirstPartyTypeKind.ZodRecord);
-class ZcRecord extends (_AbstractCompiledType$8 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcRecord, _initClass$8] } = _apply_decs_2203_r._(this, [], [
-            _dec$8
-        ], _AbstractCompiledType$8));
-    }
-    compileType() {
-        const [k, v] = [
-            compilable(this.type._def.keyType),
-            compilable(this.type._def.valueType)
-        ];
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
-            k.compileType(),
-            v.compileType()
-        ]);
-    }
-    *compileParser(ctx, path) {
-        const typeIdentifier = uniqueIdentifier('type');
-        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(typeIdentifier, ts.factory.createStringLiteral('object')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('object'),
-                received: typeIdentifier
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        const output = uniqueIdentifier('outputObject');
-        yield local(output, ts.factory.createObjectLiteralExpression());
-        const keyLabel = uniqueIdentifier('parseKey');
-        const keyInput = uniqueIdentifier('key');
-        const keyOutput = uniqueIdentifier('keyOut');
-        const valueLabel = uniqueIdentifier('parseValue');
-        const valueInput = uniqueIdentifier('value');
-        const valueOutput = uniqueIdentifier('valueOut');
-        const keyCtx = new ObjectGeneratorContext(keyLabel, keyInput, keyOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        const valueCtx = new ObjectGeneratorContext(valueLabel, valueInput, valueOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        yield ts.factory.createForInStatement(ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(keyInput)
-        ], ts.NodeFlags.Const), ctx.input, ts.factory.createBlock([
-            local(keyOutput, keyInput, true),
-            local(valueInput, ts.factory.createElementAccessExpression(ctx.input, keyInput)),
-            local(valueOutput, undefined, true),
-            ts.factory.createLabeledStatement(keyLabel, ts.factory.createBlock([
-                ...compilable(this.type._def.keyType).compileParser(keyCtx, path.push(keyInput))
-            ])),
-            ts.factory.createLabeledStatement(valueLabel, ts.factory.createBlock([
-                ...compilable(this.type._def.valueType).compileParser(valueCtx, path.push(keyOutput))
-            ])),
-            ts.factory.createExpressionStatement(ts.factory.createAssignment(ts.factory.createElementAccessExpression(output, keyOutput), valueOutput))
-        ]));
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$8();
-    }
-}
-
-var _dec$7, _initClass$7, _AbstractCompiledType$7;
-exports.ZcSet = void 0;
-_dec$7 = register(z__default.default.ZodFirstPartyTypeKind.ZodSet);
-class ZcSet extends (_AbstractCompiledType$7 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcSet, _initClass$7] } = _apply_decs_2203_r._(this, [], [
-            _dec$7
-        ], _AbstractCompiledType$7));
-    }
-    compileType() {
-        return ts.factory.createTypeReferenceNode('Set', [
-            compilable(this.type._def.valueType).compileType()
-        ]);
-    }
-    *compileParser(ctx, path) {
-        const typeIdentifier = uniqueIdentifier('type');
-        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(typeIdentifier, ts.factory.createStringLiteral('set')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('set'),
-                received: typeIdentifier
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        if (this.type._def.minSize !== null) {
-            yield ts.factory.createIfStatement(ts.factory.createLessThan(ts.factory.createPropertyAccessExpression(ctx.input, 'size'), ts.factory.createNumericLiteral(this.type._def.minSize.value)), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('too_small'),
-                    minimum: ts.factory.createNumericLiteral(this.type._def.minSize.value),
-                    type: ts.factory.createStringLiteral('set'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createFalse(),
-                    message: this.type._def.minSize.message ? ts.factory.createStringLiteral(this.type._def.minSize.message) : undefined
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        if (this.type._def.maxSize !== null) {
-            yield ts.factory.createIfStatement(ts.factory.createGreaterThan(ts.factory.createPropertyAccessExpression(ctx.input, 'size'), ts.factory.createNumericLiteral(this.type._def.maxSize.value)), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('too_big'),
-                    minimum: ts.factory.createNumericLiteral(this.type._def.maxSize.value),
-                    type: ts.factory.createStringLiteral('set'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createFalse(),
-                    message: this.type._def.maxSize.message ? ts.factory.createStringLiteral(this.type._def.maxSize.message) : undefined
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        const output = uniqueIdentifier('outputSet');
-        yield local(output, ts.factory.createNewExpression(ts.factory.createIdentifier('Set'), undefined, []));
-        const indexInitializer = ts.factory.createLoopVariable(true);
-        const elInitializer = uniqueIdentifier('el');
-        const elOutput = uniqueIdentifier('elOut');
-        const childCtx = new ArrayGeneratorContext(elInitializer, elOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-        yield ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([
-                ts.factory.createBindingElement(undefined, undefined, indexInitializer),
-                ts.factory.createBindingElement(undefined, undefined, elInitializer)
-            ]))
-        ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createArrayLiteralExpression([
-            ts.factory.createSpreadElement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ctx.input, 'values'), undefined, []))
-        ]), 'entries'), undefined, undefined), ts.factory.createBlock([
-            ...childCtx.prelude(),
-            local(elOutput, undefined, true),
-            ...compilable(this.type._def.valueType).compileParser(childCtx, path.push(indexInitializer)),
-            ...childCtx.postlude(),
-            ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(output, 'add'), undefined, [
-                elOutput
-            ]))
-        ]));
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$7();
-    }
-}
-
-const DATE = /^((\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\d|3[01])|(0[469]|11)-(0[1-9]|[12]\d|30)|(02)-(0[1-9]|1\d|2[0-8])))$/;
-
-var _dec$6, _initClass$6, _AbstractCompiledType$6;
-function timeRegexSource(args) {
-    let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
-    if (args.precision) {
-        regex = `${regex}\\.\\d{${args.precision}}`;
-    } else if (args.precision == null) {
-        regex = `${regex}(\\.\\d+)?`;
-    }
-    return regex;
-}
-function createTimeRegex(args) {
-    return `/^${timeRegexSource(args)}$/`;
-}
-function createDatetimeRegex(args) {
-    let regex = `${DATE.source.slice(1, -1)}T${timeRegexSource(args)}`;
-    const opts = [];
-    opts.push(args.local ? 'Z?' : 'Z');
-    if (args.offset) {
-        opts.push(`([+-]\\d{2}:?\\d{2})`);
-    }
-    regex = `${regex}(${opts.join('|')})`;
-    return `/^${regex}$/`;
-}
-exports.ZcString = void 0;
-_dec$6 = register(z__default.default.ZodFirstPartyTypeKind.ZodString);
-new class extends _identity._ {
-    constructor(){
-        super(exports.ZcString), _initClass$6();
-    }
-    static{
-        class ZcString extends (_AbstractCompiledType$6 = AbstractCompiledType) {
-            static{
-                ({ c: [exports.ZcString, _initClass$6] } = _apply_decs_2203_r._(this, [], [
-                    _dec$6
-                ], _AbstractCompiledType$6));
-            }
-            compileType() {
-                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-            }
-            *compileParser(ctx, path) {
-                let input = ctx.input;
-                const hasModifyingChecks = this.type._def.checks.some((a)=>a.kind === 'toLowerCase' || a.kind === 'toUpperCase' || a.kind === 'trim');
-                if (this.type._def.coerce) {
-                    const ident = uniqueIdentifier('coercedInput');
-                    yield local(ident, ts.factory.createCallExpression(ts.factory.createIdentifier('String'), [], [
-                        ctx.input
-                    ]), hasModifyingChecks);
-                    input = ident;
-                } else if (hasModifyingChecks) {
-                    const ident = uniqueIdentifier('input');
-                    yield local(ident, input, true);
-                    input = ident;
-                }
-                let stmt = ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(input), ts.factory.createStringLiteral('string')), ts.factory.createBlock([
-                    ...ctx.report(objectLiteral({
-                        path: path.serialize(),
-                        code: ts.factory.createStringLiteral('invalid_type'),
-                        expected: ts.factory.createStringLiteral('string'),
-                        received: callHelper(ctx.verifierContext, 'typeOf', input)
-                    }), input),
-                    ...ctx.status(standalone.ParseStatus.INVALID)
-                ], true));
-                const checkStmts = [];
-                for (const check of this.type._def.checks){
-                    switch(check.kind){
-                        case 'min':
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createLessThan(propertyChain(input, [
-                                'length'
-                            ]), ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('too_small'),
-                                    minimum: ts.factory.createNumericLiteral(check.value),
-                                    type: ts.factory.createStringLiteral('string'),
-                                    inclusive: ts.factory.createTrue(),
-                                    exact: ts.factory.createFalse(),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'max':
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createGreaterThan(propertyChain(input, [
-                                'length'
-                            ]), ts.factory.createNumericLiteral(check.value)), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('too_big'),
-                                    minimum: ts.factory.createNumericLiteral(check.value),
-                                    type: ts.factory.createStringLiteral('string'),
-                                    inclusive: ts.factory.createTrue(),
-                                    exact: ts.factory.createFalse(),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'length':
-                            const value = ts.factory.createNumericLiteral(check.value);
-                            const lengthAccessor = ts.factory.createPropertyAccessExpression(ctx.input, 'length');
-                            const tooBigIdent = uniqueIdentifier('tooBig');
-                            const tooSmallIdent = uniqueIdentifier('tooSmall');
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createStrictInequality(lengthAccessor, value), ts.factory.createBlock([
-                                local(tooBigIdent, ts.factory.createGreaterThan(lengthAccessor, value)),
-                                local(tooSmallIdent, ts.factory.createLessThan(lengthAccessor, value)),
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createConditionalExpression(tooBigIdent, undefined, ts.factory.createStringLiteral('too_big'), undefined, ts.factory.createStringLiteral('too_small')),
-                                    minimum: ts.factory.createConditionalExpression(tooSmallIdent, undefined, value, undefined, ts.factory.createIdentifier('undefined')),
-                                    maximum: ts.factory.createConditionalExpression(tooBigIdent, undefined, value, undefined, ts.factory.createIdentifier('undefined')),
-                                    type: ts.factory.createStringLiteral('string'),
-                                    inclusive: ts.factory.createTrue(),
-                                    exact: ts.factory.createTrue(),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'email':
-                        case 'emoji':
-                        case 'uuid':
-                        case 'nanoid':
-                        case 'cuid':
-                        case 'cuid2':
-                        case 'ulid':
-                        case 'date':
-                        case 'duration':
-                        case 'base64':
-                        case 'base64url':
-                            checkStmts.push(ZcString._basicCheck(ctx, path, input, check.kind.toUpperCase(), check.kind, check.message));
-                            break;
-                        case 'regex':
-                            checkStmts.push(ZcString._basicCheck(ctx, path, input, ts.factory.createRegularExpressionLiteral(check.regex.toString()), check.kind, check.message));
-                            break;
-                        case 'datetime':
-                            {
-                                const regex = ts.factory.createRegularExpressionLiteral(createDatetimeRegex(check));
-                                checkStmts.push(ZcString._basicCheck(ctx, path, input, regex, check.kind, check.message));
-                                break;
-                            }
-                        case 'time':
-                            {
-                                const regex = ts.factory.createRegularExpressionLiteral(createTimeRegex(check));
-                                checkStmts.push(ZcString._basicCheck(ctx, path, input, regex, check.kind, check.message));
-                                break;
-                            }
-                        case 'ip':
-                        case 'cidr':
-                            {
-                                let cidrSuffix = check.kind === 'cidr' ? '_CIDR' : '';
-                                if (!check.version) {
-                                    checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalAnd(ts.factory.createLogicalNot(ts.factory.createCallExpression(propertyChain(ctx.verifierContext, [
-                                        'regex',
-                                        `IPV4${cidrSuffix}`,
-                                        'test'
-                                    ]), undefined, [
-                                        input
-                                    ])), ts.factory.createLogicalNot(ts.factory.createCallExpression(propertyChain(ctx.verifierContext, [
-                                        'regex',
-                                        `IPV6${cidrSuffix}`,
-                                        'test'
-                                    ]), undefined, [
-                                        input
-                                    ]))), ts.factory.createBlock([
-                                        ...ctx.report(objectLiteral({
-                                            path: path.serialize(),
-                                            code: ts.factory.createStringLiteral('invalid_string'),
-                                            validation: ts.factory.createStringLiteral(check.kind),
-                                            message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                        }), input),
-                                        ...ctx.status(standalone.ParseStatus.DIRTY)
-                                    ], true)));
-                                } else {
-                                    checkStmts.push(ZcString._basicCheck(ctx, path, input, `IP${check.version.toUpperCase()}${cidrSuffix}`, check.kind, check.message));
-                                }
-                                break;
-                            }
-                        case 'url':
-                            checkStmts.push(ts.factory.createTryStatement(ts.factory.createBlock([
-                                ts.factory.createExpressionStatement(ts.factory.createNewExpression(ts.factory.createIdentifier('URL'), undefined, [
-                                    input
-                                ]))
-                            ], true), ts.factory.createCatchClause(uniqueIdentifier('e'), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('invalid_string'),
-                                    validation: ts.factory.createStringLiteral('url'),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)), undefined));
-                            break;
-                        case 'jwt':
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalNot(callHelper(ctx.verifierContext, 'isValidJWT', input, check.alg ? ts.factory.createStringLiteral(check.alg) : ts.factory.createIdentifier('undefined'))), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('invalid_string'),
-                                    validation: ts.factory.createStringLiteral('url'),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'startsWith':
-                        case 'endsWith':
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(input, check.kind), undefined, [
-                                ts.factory.createStringLiteral(check.value)
-                            ])), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('invalid_string'),
-                                    validation: objectLiteral({
-                                        [check.kind]: ts.factory.createStringLiteral(check.value)
-                                    }),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'includes':
-                            checkStmts.push(ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(input, 'includes'), undefined, [
-                                ts.factory.createStringLiteral(check.value),
-                                check.position ? ts.factory.createNumericLiteral(check.position) : ts.factory.createIdentifier('undefined')
-                            ])), ts.factory.createBlock([
-                                ...ctx.report(objectLiteral({
-                                    path: path.serialize(),
-                                    code: ts.factory.createStringLiteral('invalid_string'),
-                                    validation: objectLiteral({
-                                        includes: ts.factory.createStringLiteral(check.value),
-                                        position: check.position ? ts.factory.createNumericLiteral(check.position) : undefined
-                                    }),
-                                    message: check.message ? ts.factory.createStringLiteral(check.message) : undefined
-                                }), input),
-                                ...ctx.status(standalone.ParseStatus.DIRTY)
-                            ], true)));
-                            break;
-                        case 'trim':
-                        case 'toLowerCase':
-                        case 'toUpperCase':
-                            {
-                                checkStmts.push(ts.factory.createExpressionStatement(ts.factory.createAssignment(input, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(input, check.kind), undefined, []))));
-                                break;
-                            }
-                        default:
-                            throw new Error(`Unsupported ZcString check: ${check}`);
-                    }
-                }
-                if (checkStmts.length === 0) {
-                    yield stmt;
-                } else {
-                    stmt = ts.factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, ts.factory.createBlock([
-                        ...checkStmts
-                    ], true));
-                    yield stmt;
-                }
-                yield* ctx.outputs(input);
-            }
-            static _basicCheck(ctx, path, input, regexOrTester, checkKind, message) {
-                const testFunction = typeof regexOrTester === 'string' ? propertyChain(ctx.verifierContext, [
-                    'regex',
-                    regexOrTester,
-                    'test'
-                ]) : ts__default.default.isRegularExpressionLiteral(regexOrTester) ? ts.factory.createPropertyAccessExpression(regexOrTester, 'test') : regexOrTester;
-                return ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(testFunction, undefined, [
-                    input
-                ])), ts.factory.createBlock([
-                    ...ctx.report(objectLiteral({
-                        path: path.serialize(),
-                        code: ts.factory.createStringLiteral('invalid_string'),
-                        validation: ts.factory.createStringLiteral(checkKind),
-                        message: message ? ts.factory.createStringLiteral(message) : undefined
-                    }), input),
-                    ...ctx.status(standalone.ParseStatus.DIRTY)
-                ], true));
-            }
-        }
-    }
-}();
-
-var _dec$5, _initClass$5, _AbstractCompiledType$5;
-exports.ZcSymbol = void 0;
-_dec$5 = register(z__default.default.ZodFirstPartyTypeKind.ZodSymbol);
-class ZcSymbol extends (_AbstractCompiledType$5 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcSymbol, _initClass$5] } = _apply_decs_2203_r._(this, [], [
-            _dec$5
-        ], _AbstractCompiledType$5));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.SymbolKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('symbol')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('symbol'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$5();
-    }
-}
-
-var _dec$4, _initClass$4, _AbstractCompiledType$4;
-exports.ZcTuple = void 0;
-_dec$4 = register(z__default.default.ZodFirstPartyTypeKind.ZodTuple);
-class ZcTuple extends (_AbstractCompiledType$4 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcTuple, _initClass$4] } = _apply_decs_2203_r._(this, [], [
-            _dec$4
-        ], _AbstractCompiledType$4));
-    }
-    compileType() {
-        const items = [];
-        for (const item of this.type._def.items){
-            items.push(compilable(item).compileType());
-        }
-        if (this.type._def.rest) {
-            items.push(ts.factory.createRestTypeNode(compilable(this.type._def.rest).compileType()));
-        }
-        return ts.factory.createTupleTypeNode(items);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Array'), 'isArray'), undefined, [
-            ctx.input
-        ])), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('array'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield ts.factory.createIfStatement(ts.factory.createLessThan(ts.factory.createPropertyAccessExpression(ctx.input, 'length'), ts.factory.createNumericLiteral(this.type._def.items.length)), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('too_small'),
-                minimum: ts.factory.createNumericLiteral(this.type._def.items.length),
-                type: ts.factory.createStringLiteral('array'),
-                inclusive: ts.factory.createTrue(),
-                exact: ts.factory.createFalse()
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        if (!this.type._def.rest) {
-            yield ts.factory.createIfStatement(ts.factory.createGreaterThan(ts.factory.createPropertyAccessExpression(ctx.input, 'length'), ts.factory.createNumericLiteral(this.type._def.items.length)), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('too_big'),
-                    minimum: ts.factory.createNumericLiteral(this.type._def.items.length),
-                    type: ts.factory.createStringLiteral('array'),
-                    inclusive: ts.factory.createTrue(),
-                    exact: ts.factory.createFalse()
-                })),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true));
-        }
-        const output = uniqueIdentifier('outputTuple');
-        yield local(output, ts.factory.createNewExpression(ts.factory.createIdentifier('Array'), undefined, [
-            ts.factory.createPropertyAccessExpression(ctx.input, 'length')
-        ]));
-        for (const [i, ty] of this.type._def.items.entries()){
-            const label = uniqueIdentifier(`item${i}`);
-            const inputExpr = propertyChain(ctx.input, [
-                i
-            ]);
-            const outputExpr = propertyChain(output, [
-                i
-            ]);
-            const childCtx = new ObjectGeneratorContext(label, inputExpr, outputExpr, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-            yield ts.factory.createLabeledStatement(label, ts.factory.createBlock([
-                ...compilable(ty).compileParser(childCtx, path.push(i))
-            ]));
-        }
-        if (this.type._def.rest) {
-            const indexInitializer = ts.factory.createLoopVariable(true);
-            const elInitializer = uniqueIdentifier('el');
-            const elOutput = ts.factory.createElementAccessExpression(output, indexInitializer);
-            const childCtx = new ArrayGeneratorContext(elInitializer, elOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
-            yield ts.factory.createForStatement(local(indexInitializer, ts.factory.createNumericLiteral(this.type._def.items.length), true).declarationList, ts.factory.createLessThan(indexInitializer, ts.factory.createPropertyAccessExpression(ctx.input, 'length')), ts.factory.createPostfixIncrement(indexInitializer), ts.factory.createBlock([
-                local(elInitializer, ts.factory.createElementAccessExpression(ctx.input, indexInitializer)),
-                ...childCtx.prelude(),
-                ...compilable(this.type._def.rest).compileParser(childCtx, path.push(indexInitializer)),
-                ...childCtx.postlude()
-            ]));
-        }
-        yield* ctx.outputs(output);
-    }
-    static{
-        _initClass$4();
-    }
-}
-
-var _dec$3, _initClass$3, _AbstractCompiledType$3;
-exports.ZcUndefined = void 0;
-_dec$3 = register(z__default.default.ZodFirstPartyTypeKind.ZodUndefined);
-class ZcUndefined extends (_AbstractCompiledType$3 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcUndefined, _initClass$3] } = _apply_decs_2203_r._(this, [], [
-            _dec$3
-        ], _AbstractCompiledType$3));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('undefined')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('undefined'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$3();
-    }
-}
-
-var _dec$2, _initClass$2, _AbstractCompiledType$2;
-class UnionGeneratorContext extends LabeledBlockScopeGeneratorContext {
-    constructor(label, input, output, verifierContext, dependencies, parent){
-        super(LabeledShortCircuitMode.Break, label, input, output, verifierContext, dependencies), this.parent = parent;
-    }
-    *postlude() {
-        yield ts.factory.createIfStatement(ts.factory.createStrictEquality(this.statusVar, ts.factory.createNumericLiteral(standalone.ParseStatus.VALID)), ts.factory.createBlock([
-            ...this.parent.ctx.outputs(this.output),
-            ts.factory.createBreakStatement(this.parent.label)
-        ], true), ts.factory.createIfStatement(ts.factory.createLogicalAnd(ts.factory.createStrictEquality(this.statusVar, ts.factory.createNumericLiteral(standalone.ParseStatus.DIRTY)), ts.factory.createLogicalNot(this.parent.dirtyResultVar)), ts.factory.createBlock([
-            ts.factory.createExpressionStatement(ts.factory.createAssignment(this.parent.dirtyResultVar, this.output)),
-            ts.factory.createExpressionStatement(ts.factory.createAssignment(this.parent.dirtyCtxVar, this.verifierContext))
-        ])));
-        // imho, this shouldn't be behind a condition, but it's how zod does it and I promise parity
-        const childIssues = ts.factory.createPropertyAccessExpression(this.verifierContext, 'issues');
-        yield ts.factory.createIfStatement(ts.factory.createPropertyAccessExpression(childIssues, 'length'), ts.factory.createBlock([
-            ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(this.parent.issues, 'push'), undefined, [
-                childIssues
-            ]))
-        ], true));
-    }
-    withInput(expr) {
-        const x = new UnionGeneratorContext(this.label, expr, this.output, this.verifierContext, this.dependencies, this.parent);
-        x.statusVar = this.statusVar;
-        return x;
-    }
-}
-exports.ZcUnion = void 0;
-_dec$2 = register(z__default.default.ZodFirstPartyTypeKind.ZodUnion);
-class ZcUnion extends (_AbstractCompiledType$2 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcUnion, _initClass$2] } = _apply_decs_2203_r._(this, [], [
-            _dec$2
-        ], _AbstractCompiledType$2));
-    }
-    compileType() {
-        return ts.factory.createUnionTypeNode(this.type._def.options.map((ty)=>compilable(ty).compileType()));
-    }
-    *compileParser(ctx, path) {
-        const dirtyResultVar = uniqueIdentifier('unionDirtyResult');
-        const dirtyCtxVar = uniqueIdentifier('unionDirtyCtx');
-        const issuesVar = uniqueIdentifier('unionIssues');
-        yield local(dirtyResultVar, undefined, true);
-        yield local(dirtyCtxVar, undefined, true);
-        yield local(issuesVar, ts.factory.createArrayLiteralExpression(), false);
-        const mainLabel = uniqueIdentifier('union');
-        yield ts.factory.createLabeledStatement(mainLabel, ts.factory.createBlock([
-            ...this.type._def.options.flatMap((opt, i)=>{
-                function* generateBody() {
-                    const ty = compilable(opt);
-                    const variantLabel = uniqueIdentifier(`unionVariant_${i}`);
-                    const tmpOutput = uniqueIdentifier('variantOutput');
-                    const childVerifierCtxVar = uniqueIdentifier('variantCtx');
-                    yield local(tmpOutput, undefined, true);
-                    yield local(childVerifierCtxVar, ts.factory.createObjectLiteralExpression([
-                        ts.factory.createSpreadAssignment(ctx.verifierContext),
-                        ts.factory.createPropertyAssignment('issues', ts.factory.createArrayLiteralExpression())
-                    ], true));
-                    const childCtx = new UnionGeneratorContext(variantLabel, ctx.input, tmpOutput, childVerifierCtxVar, ctx.dependencies, {
-                        ctx,
-                        label: mainLabel,
-                        dirtyCtxVar,
-                        dirtyResultVar,
-                        issues: issuesVar
-                    });
-                    yield* childCtx.prelude();
-                    yield ts.factory.createLabeledStatement(variantLabel, ts.factory.createBlock([
-                        ...ty.compileParser(childCtx, path)
-                    ], true));
-                    yield* childCtx.postlude();
-                }
-                return [
-                    ...generateBody()
-                ];
-            }),
-            ts.factory.createIfStatement(dirtyCtxVar, ts.factory.createBlock([
-                ...ctx.report(ts.factory.createSpreadElement(ts.factory.createPropertyAccessExpression(dirtyCtxVar, 'issues'))),
-                ...ctx.status(standalone.ParseStatus.DIRTY)
-            ], true), ts.factory.createBlock([
-                ...ctx.report(objectLiteral({
-                    path: path.serialize(),
-                    code: ts.factory.createStringLiteral('invalid_union'),
-                    unionErrors: ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(issuesVar, 'map'), undefined, [
-                        ts.factory.createArrowFunction(undefined, undefined, [
-                            ts.factory.createParameterDeclaration(undefined, undefined, 'issues')
-                        ], undefined, undefined, ts.factory.createNewExpression(ts.factory.createPropertyAccessExpression(ctx.verifierContext, 'ZcError'), undefined, [
-                            ts.factory.createIdentifier('issues')
-                        ]))
-                    ])
-                })),
-                ...ctx.status(standalone.ParseStatus.INVALID)
-            ], true))
-        ]));
-    }
-    static{
-        _initClass$2();
-    }
-}
-
-var _dec$1, _initClass$1, _AbstractCompiledType$1;
-exports.ZcUnknown = void 0;
-_dec$1 = register(z__default.default.ZodFirstPartyTypeKind.ZodUnknown);
-class ZcUnknown extends (_AbstractCompiledType$1 = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcUnknown, _initClass$1] } = _apply_decs_2203_r._(this, [], [
-            _dec$1
-        ], _AbstractCompiledType$1));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass$1();
-    }
-}
-
-var _dec, _initClass, _AbstractCompiledType;
-exports.ZcVoid = void 0;
-_dec = register(z__default.default.ZodFirstPartyTypeKind.ZodVoid);
-class ZcVoid extends (_AbstractCompiledType = AbstractCompiledType) {
-    static{
-        ({ c: [exports.ZcVoid, _initClass] } = _apply_decs_2203_r._(this, [], [
-            _dec
-        ], _AbstractCompiledType));
-    }
-    compileType() {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
-    }
-    *compileParser(ctx, path) {
-        yield ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(ctx.input), ts.factory.createStringLiteral('undefined')), ts.factory.createBlock([
-            ...ctx.report(objectLiteral({
-                path: path.serialize(),
-                code: ts.factory.createStringLiteral('invalid_type'),
-                expected: ts.factory.createStringLiteral('undefined'),
-                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
-            })),
-            ...ctx.status(standalone.ParseStatus.INVALID)
-        ], true));
-        yield* ctx.outputs(ctx.input);
-    }
-    static{
-        _initClass();
-    }
-}
-
-function compile(schema, options) {
-    const type = compilable(schema);
-    const verifierContext = ts.factory.createIdentifier('ctx');
-    const dependencies = new Dependencies(verifierContext, options?.inlining ?? InliningMode.Default);
-    const ctx = new FunctionalGeneratorContext(ts.factory.createIdentifier('input'), propertyChain(ts.factory.createIdentifier('ctx'), [
-        'output'
-    ]), verifierContext, dependencies);
-    const functionBody = [
-        ...ctx.prelude(),
-        ...type.compileParser(ctx, Path.empty()),
-        ...ctx.postlude()
-    ];
-    if (options?.standalone) {
-        return {
-            source: print(ts.factory.createFunctionExpression(undefined, undefined, undefined, undefined, [
-                ts.factory.createParameterDeclaration(undefined, undefined, 'input'),
-                ts.factory.createParameterDeclaration(undefined, undefined, 'ctx')
-            ], undefined, ts.factory.createBlock(functionBody, true))),
-            dependencies: dependencies.dependencies,
-            get hasDependencies () {
-                return dependencies.dependencies.length > 0;
-            }
-        };
-    }
-    const sourceFile = ts.factory.createSourceFile(functionBody, ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    // Usage of `factory.createUniqueName` requires that `identifiers` is defined and a read-only `Map`. This is usually
-    // done after a source file is parsed, but we never do that, so this map doesn't get created and emitting throws errors.
-    // Since this is an internal property, this may break on future/older TypeScript versions.
-    sourceFile.identifiers = new Map();
-    const source = print(sourceFile);
-    const parser = new Function('input', 'ctx', source);
-    return standalone__default.default(parser, dependencies.dependencies);
-}
-/**
- * Exports the `schema` to a TypeScript type definition.
- * 
- * ```ts
- * import z from 'zod';
- * import zc from 'zod-compiler';
- * 
- * const schema = z.string();
- * 
- * console.log(zc.types(schema));
- * // export type Schema = string;
- * ```
- */ function types(schema, options) {
-    const typeDef = compilable(schema).compileType();
-    if (options?.asExport ?? true) {
-        return print(ts.factory.createSourceFile([
-            ts.factory.createTypeAliasDeclaration([
-                ts.factory.createToken(ts.SyntaxKind.ExportKeyword)
-            ], options?.schemaName ?? 'Schema', undefined, typeDef)
-        ], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None));
-    } else {
-        return print(typeDef);
-    }
-}
-
-var zc = {
-	__proto__: null,
-	AbstractCompiledType: AbstractCompiledType,
-	InliningMode: InliningMode,
-	get ZcAny () { return exports.ZcAny; },
-	get ZcArray () { return exports.ZcArray; },
-	get ZcBigInt () { return exports.ZcBigInt; },
-	get ZcBoolean () { return exports.ZcBoolean; },
-	get ZcBranded () { return exports.ZcBranded; },
-	get ZcCatch () { return exports.ZcCatch; },
-	get ZcDate () { return exports.ZcDate; },
-	get ZcDefault () { return exports.ZcDefault; },
-	get ZcDiscriminatedUnion () { return exports.ZcDiscriminatedUnion; },
-	get ZcEnum () { return exports.ZcEnum; },
-	ZcError: ZcError,
-	get ZcIntersection () { return exports.ZcIntersection; },
-	get ZcLiteral () { return exports.ZcLiteral; },
-	get ZcMap () { return exports.ZcMap; },
-	get ZcNaN () { return exports.ZcNaN; },
-	get ZcNativeEnum () { return exports.ZcNativeEnum; },
-	get ZcNever () { return exports.ZcNever; },
-	get ZcNull () { return exports.ZcNull; },
-	get ZcNullable () { return exports.ZcNullable; },
-	get ZcNumber () { return exports.ZcNumber; },
-	get ZcObject () { return exports.ZcObject; },
-	get ZcOptional () { return exports.ZcOptional; },
-	get ZcReadonly () { return exports.ZcReadonly; },
-	get ZcRecord () { return exports.ZcRecord; },
-	get ZcSet () { return exports.ZcSet; },
-	get ZcString () { return exports.ZcString; },
-	get ZcSymbol () { return exports.ZcSymbol; },
-	get ZcTuple () { return exports.ZcTuple; },
-	get ZcUndefined () { return exports.ZcUndefined; },
-	get ZcUnion () { return exports.ZcUnion; },
-	get ZcUnknown () { return exports.ZcUnknown; },
-	get ZcVoid () { return exports.ZcVoid; },
-	compilable: compilable,
-	compile: compile,
-	types: types
-};
-
-exports.AbstractCompiledType = AbstractCompiledType;
-exports.InliningMode = InliningMode;
-exports.ZcError = ZcError;
-exports.compilable = compilable;
-exports.compile = compile;
-exports.default = zc;
-exports.types = types;
+export { compile, isCompiledSchema } from "#src/core/compile.js";
+//# sourceMappingURL=index.js.map