zod-compiler 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2536 @@
+import ts, { factory, NodeFlags, EmitHint, TokenFlags, ScriptTarget, ScriptKind, SyntaxKind } from 'typescript';
+import standalone, { ParseStatus } from './standalone.mjs';
+import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
+import z from 'zod';
+import { _ as _$1 } from '@swc/helpers/_/_identity';
+
+function uniqueIdentifier(name) {
+    return factory.createUniqueName(name, ts.GeneratedIdentifierFlags.ReservedInNestedScopes);
+}
+function local(ident, initializer, modifiable = false) {
+    return factory.createVariableStatement([], factory.createVariableDeclarationList([
+        factory.createVariableDeclaration(ident, undefined, undefined, initializer)
+    ], !modifiable ? NodeFlags.Const : NodeFlags.Let));
+}
+function objectLiteral(obj) {
+    const entries = Object.entries(obj).filter(([k, v])=>!!v);
+    return factory.createObjectLiteralExpression(entries.map(([name, expr])=>factory.createPropertyAssignment(factory.createStringLiteral(name), expr)), entries.length > 1);
+}
+const IDENT_REGEX = /^[$A-Z_a-z][\w$]*$/;
+function identifierOrStringLiteral(value) {
+    if (IDENT_REGEX.test(value)) {
+        return factory.createIdentifier(value);
+    } else {
+        return factory.createStringLiteral(value);
+    }
+}
+function propertyChain(start, elements) {
+    for (let element of elements){
+        if (typeof element === 'string') {
+            if (IDENT_REGEX.test(element)) {
+                start = factory.createPropertyAccessExpression(start, element);
+                continue;
+            }
+            element = factory.createStringLiteral(element);
+        }
+        start = factory.createElementAccessExpression(start, element);
+    }
+    return start;
+}
+function print(node, hint = EmitHint.Unspecified) {
+    const file = ts.createSourceFile('print.ts', '', ScriptTarget.ES2022, false, ScriptKind.TS);
+    const printer = ts.createPrinter();
+    return printer.printNode(hint, node, file);
+}
+function callHelper(verifierContext, helper, ...args) {
+    return 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(factory.createStringLiteral(fragment));
+        } else if (typeof fragment === 'number') {
+            parts.push(factory.createNumericLiteral(fragment, TokenFlags.None));
+        } else {
+            parts.push(fragment);
+        }
+        return new Path(parts);
+    }
+    serialize() {
+        return 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 factory.createExpressionStatement(factory.createAssignment(this._output, expr));
+    }
+    *report(issue, input = this.input) {
+        yield factory.createExpressionStatement(factory.createCallExpression(propertyChain(this.verifierContext, [
+            'reportIssue'
+        ]), undefined, [
+            issue,
+            input
+        ]));
+    }
+}
+class AbstractGeneratorContextWithExprsAndStatusVar extends AbstractGeneratorContextWithExprs {
+    *prelude() {
+        yield factory.createVariableStatement([], factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(this.statusVar, undefined, undefined, factory.createNumericLiteral(ParseStatus.VALID))
+        ], NodeFlags.Let));
+    }
+    constructor(...args){
+        super(...args), this.statusVar = uniqueIdentifier('status');
+    }
+}
+class FunctionalGeneratorContext extends AbstractGeneratorContextWithExprsAndStatusVar {
+    *postlude() {
+        yield factory.createReturnStatement(this.statusVar);
+    }
+    *status(status, allowShortCircuiting = true) {
+        if (typeof status === 'number') {
+            if (status === ParseStatus.INVALID && allowShortCircuiting) {
+                yield factory.createReturnStatement(factory.createNumericLiteral(status));
+            } else {
+                yield factory.createExpressionStatement(factory.createBinaryExpression(this.statusVar, SyntaxKind.BarEqualsToken, factory.createNumericLiteral(status)));
+            }
+        } else {
+            if (allowShortCircuiting) {
+                yield factory.createIfStatement(factory.createBitwiseAnd(status, factory.createNumericLiteral(ParseStatus.INVALID)), factory.createReturnStatement(status));
+            }
+            yield factory.createExpressionStatement(factory.createBinaryExpression(this.statusVar, 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 factory.createExpressionStatement(factory.createBinaryExpression(this.statusVar, SyntaxKind.BarEqualsToken, typeof status === 'number' ? factory.createNumericLiteral(status) : status));
+        if (allowShortCircuiting) {
+            const shortCircuit = ()=>{
+                switch(this.mode){
+                    case 1:
+                        return factory.createBreakStatement(this.label);
+                    case 0:
+                        return factory.createContinueStatement(this.label);
+                }
+            };
+            if (status === ParseStatus.INVALID) {
+                yield shortCircuit();
+            } else {
+                yield factory.createIfStatement(factory.createBitwiseAnd(this.statusVar, factory.createNumericLiteral(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 factory.createStringLiteral(value);
+        case 'number':
+            return factory.createNumericLiteral(value);
+        case 'bigint':
+            return factory.createBigIntLiteral(value.toString());
+        case 'undefined':
+            return factory.createIdentifier('undefined');
+        case 'boolean':
+            return value ? factory.createTrue() : factory.createFalse();
+        case 'object':
+            if (value === null) {
+                return factory.createNull();
+            }
+            if (mode === 2) {
+                if (value instanceof RegExp) {
+                    return factory.createRegularExpressionLiteral(value.toString());
+                } else if (value instanceof Map) {
+                    return factory.createNewExpression(factory.createIdentifier('Map'), undefined, [
+                        factory.createArrayLiteralExpression([
+                            ...value.entries()
+                        ].map(([k, v])=>factory.createArrayLiteralExpression([
+                                toLiteral(k, mode),
+                                toLiteral(v, mode)
+                            ])))
+                    ]);
+                } else if (value instanceof Set) {
+                    return factory.createNewExpression(factory.createIdentifier('Set'), undefined, [
+                        factory.createArrayLiteralExpression([
+                            ...value.values()
+                        ].map((v)=>toLiteral(v, mode)))
+                    ]);
+                } else if (Array.isArray(value)) {
+                    return factory.createArrayLiteralExpression(value.map((v)=>toLiteral(v, mode)));
+                } else if (value instanceof Date) {
+                    return factory.createNewExpression(factory.createIdentifier('Date'), undefined, [
+                        factory.createNumericLiteral(value.getTime())
+                    ]);
+                } else if (value.constructor === Object) {
+                    return factory.createObjectLiteralExpression(Object.entries(value).map(([k, v])=>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;
+let _ZcAny;
+_dec$u = register(z.ZodFirstPartyTypeKind.ZodAny);
+class ZcAny extends (_AbstractCompiledType$u = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcAny, _initClass$u] } = _(this, [], [
+            _dec$u
+        ], _AbstractCompiledType$u));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(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' ? factory.createNumericLiteral(status) : status);
+        if (allowShortCircuiting) {
+            if (status === ParseStatus.INVALID) {
+                yield factory.createContinueStatement();
+            } else if (typeof status !== 'number') {
+                yield factory.createIfStatement(factory.createBitwiseAnd(status, factory.createNumericLiteral(ParseStatus.INVALID)), factory.createContinueStatement());
+            }
+        }
+    }
+    withInput(expr) {
+        const x = new ArrayGeneratorContext(expr, this.output, this.verifierContext, this.dependencies, this.parentStatusSetter);
+        x.statusVar = this.statusVar;
+        return x;
+    }
+}
+let _ZcArray;
+_dec$t = register(z.ZodFirstPartyTypeKind.ZodArray);
+class ZcArray extends (_AbstractCompiledType$t = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcArray, _initClass$t] } = _(this, [], [
+            _dec$t
+        ], _AbstractCompiledType$t));
+    }
+    compileType() {
+        return factory.createArrayTypeNode(compilable(this.type._def.type).compileType());
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Array'), 'isArray'), undefined, [
+            ctx.input
+        ])), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('array'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        if (this.type._def.exactLength !== null) {
+            const value = factory.createNumericLiteral(this.type._def.exactLength.value);
+            const lengthAccessor = factory.createPropertyAccessExpression(ctx.input, 'length');
+            const tooBigIdent = uniqueIdentifier('tooBig');
+            const tooSmallIdent = uniqueIdentifier('tooSmall');
+            yield factory.createIfStatement(factory.createStrictInequality(lengthAccessor, value), factory.createBlock([
+                local(tooBigIdent, factory.createGreaterThan(lengthAccessor, value)),
+                local(tooSmallIdent, factory.createLessThan(lengthAccessor, value)),
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createConditionalExpression(tooBigIdent, undefined, factory.createStringLiteral('too_big'), undefined, factory.createStringLiteral('too_small')),
+                    minimum: factory.createConditionalExpression(tooSmallIdent, undefined, value, undefined, factory.createIdentifier('undefined')),
+                    maximum: factory.createConditionalExpression(tooBigIdent, undefined, value, undefined, factory.createIdentifier('undefined')),
+                    type: factory.createStringLiteral('array'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createTrue(),
+                    message: this.type._def.exactLength.message ? factory.createStringLiteral(this.type._def.exactLength.message) : undefined
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        if (this.type._def.minLength !== null) {
+            yield factory.createIfStatement(factory.createLessThan(factory.createPropertyAccessExpression(ctx.input, 'length'), factory.createNumericLiteral(this.type._def.minLength.value)), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('too_small'),
+                    minimum: factory.createNumericLiteral(this.type._def.minLength.value),
+                    type: factory.createStringLiteral('array'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createFalse(),
+                    message: this.type._def.minLength.message ? factory.createStringLiteral(this.type._def.minLength.message) : undefined
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        if (this.type._def.maxLength !== null) {
+            yield factory.createIfStatement(factory.createGreaterThan(factory.createPropertyAccessExpression(ctx.input, 'length'), factory.createNumericLiteral(this.type._def.maxLength.value)), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('too_big'),
+                    minimum: factory.createNumericLiteral(this.type._def.maxLength.value),
+                    type: factory.createStringLiteral('array'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createFalse(),
+                    message: this.type._def.maxLength.message ? factory.createStringLiteral(this.type._def.maxLength.message) : undefined
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        const output = uniqueIdentifier('outputArray');
+        yield local(output, factory.createNewExpression(factory.createIdentifier('Array'), undefined, [
+            factory.createPropertyAccessExpression(ctx.input, 'length')
+        ]));
+        const indexInitializer = factory.createLoopVariable(true);
+        const elInitializer = uniqueIdentifier('el');
+        const elOutput = factory.createElementAccessExpression(output, indexInitializer);
+        const childCtx = new ArrayGeneratorContext(elInitializer, elOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
+        yield factory.createForOfStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(factory.createArrayBindingPattern([
+                factory.createBindingElement(undefined, undefined, indexInitializer),
+                factory.createBindingElement(undefined, undefined, elInitializer)
+            ]))
+        ], NodeFlags.Const), factory.createCallExpression(factory.createPropertyAccessExpression(ctx.input, 'entries'), undefined, undefined), 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;
+let _ZcBigInt;
+_dec$s = register(z.ZodFirstPartyTypeKind.ZodBigInt);
+class ZcBigInt extends (_AbstractCompiledType$s = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcBigInt, _initClass$s] } = _(this, [], [
+            _dec$s
+        ], _AbstractCompiledType$s));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(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 factory.createTryStatement(factory.createBlock([
+                factory.createExpressionStatement(factory.createAssignment(ident, factory.createCallExpression(factory.createIdentifier('BigInt'), undefined, [
+                    ctx.input
+                ])))
+            ], true), factory.createCatchClause(uniqueIdentifier('e'), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('invalid_type'),
+                    expected: 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(ParseStatus.INVALID)
+            ], true)), undefined);
+        }
+        let stmt = factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(input), factory.createStringLiteral('bigint')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('bigint'),
+                received: callHelper(ctx.verifierContext, 'typeOf', input)
+            }), input),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        const checkStmts = [];
+        for (const check of this.type._def.checks){
+            switch(check.kind){
+                case 'min':
+                    checkStmts.push(factory.createIfStatement(factory[check.inclusive ? 'createLessThan' : 'createLessThanEquals'](input, factory.createBigIntLiteral(check.value.toString())), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_small'),
+                            minimum: factory.createBigIntLiteral(check.value.toString()),
+                            type: factory.createStringLiteral('bigint'),
+                            inclusive: check.inclusive ? factory.createTrue() : factory.createFalse(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'max':
+                    checkStmts.push(factory.createIfStatement(factory[check.inclusive ? 'createGreaterThan' : 'createGreaterThanEquals'](input, factory.createBigIntLiteral(check.value.toString())), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_big'),
+                            minimum: factory.createBigIntLiteral(check.value.toString()),
+                            type: factory.createStringLiteral('bigint'),
+                            inclusive: check.inclusive ? factory.createTrue() : factory.createFalse(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'multipleOf':
+                    checkStmts.push(factory.createIfStatement(factory.createStrictInequality(factory.createModulo(input, factory.createBigIntLiteral(check.value.toString())), factory.createBigIntLiteral('0')), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('not_multiple_of'),
+                            multipleOf: factory.createBigIntLiteral(check.value.toString()),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                default:
+                    throw new Error(`Unsupported ZcBigInt check: ${check}`);
+            }
+        }
+        if (checkStmts.length === 0) {
+            yield stmt;
+        } else {
+            stmt = factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, factory.createBlock([
+                ...checkStmts
+            ], true));
+            yield stmt;
+        }
+        yield* ctx.outputs(input);
+    }
+    static{
+        _initClass$s();
+    }
+}
+
+var _dec$r, _initClass$r, _AbstractCompiledType$r;
+let _ZcBoolean;
+_dec$r = register(z.ZodFirstPartyTypeKind.ZodBoolean);
+class ZcBoolean extends (_AbstractCompiledType$r = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcBoolean, _initClass$r] } = _(this, [], [
+            _dec$r
+        ], _AbstractCompiledType$r));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword);
+    }
+    *compileParser(ctx, path) {
+        let input = ctx.input;
+        if (this.type._def.coerce) {
+            const ident = uniqueIdentifier('coercedInput');
+            yield local(ident, factory.createCallExpression(factory.createIdentifier('Boolean'), [], [
+                ctx.input
+            ]), false);
+            input = ident;
+        }
+        yield factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(input), factory.createStringLiteral('boolean')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('boolean'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            }), input),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass$r();
+    }
+}
+
+var _dec$q, _initClass$q, _AbstractCompiledType$q;
+let _ZcBranded;
+_dec$q = register(z.ZodFirstPartyTypeKind.ZodBranded);
+class ZcBranded extends (_AbstractCompiledType$q = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcBranded, _initClass$q] } = _(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;
+    }
+}
+let _ZcCatch;
+_dec$p = register(z.ZodFirstPartyTypeKind.ZodCatch);
+class ZcCatch extends (_AbstractCompiledType$p = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcCatch, _initClass$p] } = _(this, [], [
+            _dec$p
+        ], _AbstractCompiledType$p));
+    }
+    compileType() {
+        return compilable(this.type._def.innerType).compileType();
+    }
+    *compileParser(ctx, path) {
+        const caughtStatus = uniqueIdentifier('caughtStatus');
+        yield local(caughtStatus, factory.createNumericLiteral(ParseStatus.VALID), true);
+        const output = uniqueIdentifier('caughtOutput');
+        yield local(output, undefined, true);
+        const verifierCtxVar = uniqueIdentifier('variantCtx');
+        yield local(verifierCtxVar, factory.createObjectLiteralExpression([
+            factory.createSpreadAssignment(ctx.verifierContext),
+            factory.createPropertyAssignment('issues', 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 factory.createLabeledStatement(label, factory.createBlock([
+            ...childCtx.prelude(),
+            ...compilable(this.type._def.innerType).compileParser(childCtx, path),
+            ...childCtx.postlude()
+        ]));
+        yield factory.createIfStatement(factory.createStrictInequality(caughtStatus, factory.createNumericLiteral(ParseStatus.VALID)), factory.createBlock([
+            ...ctx.outputs(catchValue)
+        ], true), factory.createBlock([
+            ...ctx.outputs(output)
+        ], true));
+    }
+    static{
+        _initClass$p();
+    }
+}
+
+var _dec$o, _initClass$o, _AbstractCompiledType$o;
+let _ZcDate;
+_dec$o = register(z.ZodFirstPartyTypeKind.ZodDate);
+class ZcDate extends (_AbstractCompiledType$o = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcDate, _initClass$o] } = _(this, [], [
+            _dec$o
+        ], _AbstractCompiledType$o));
+    }
+    compileType() {
+        return factory.createTypeReferenceNode('Date');
+    }
+    *compileParser(ctx, path) {
+        let input = ctx.input;
+        if (this.type._def.coerce) {
+            const ident = uniqueIdentifier('coercedInput');
+            yield local(ident, factory.createNewExpression(factory.createIdentifier('Date'), [], [
+                ctx.input
+            ]), false);
+            input = ident;
+        }
+        let stmt = factory.createIfStatement(factory.createLogicalNot(factory.createBinaryExpression(input, SyntaxKind.InstanceOfKeyword, factory.createIdentifier('Date'))), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('date'),
+                received: callHelper(ctx.verifierContext, 'typeOf', input)
+            }), input),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        const timeVar = uniqueIdentifier('time');
+        const checkStmts = [
+            local(timeVar, factory.createCallExpression(factory.createPropertyAccessExpression(input, 'getTime'), undefined, [])),
+            factory.createIfStatement(factory.createCallExpression(factory.createIdentifier('isNaN'), undefined, [
+                timeVar
+            ]), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('invalid_date')
+                }), input),
+                ...ctx.status(ParseStatus.INVALID)
+            ], true))
+        ];
+        for (const check of this.type._def.checks){
+            switch(check.kind){
+                case 'min':
+                    checkStmts.push(factory.createIfStatement(factory.createLessThan(timeVar, factory.createNumericLiteral(check.value)), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_small'),
+                            minimum: factory.createNumericLiteral(check.value),
+                            type: factory.createStringLiteral('date'),
+                            inclusive: factory.createTrue(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'max':
+                    checkStmts.push(factory.createIfStatement(factory.createGreaterThan(timeVar, factory.createNumericLiteral(check.value)), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_big'),
+                            minimum: factory.createNumericLiteral(check.value),
+                            type: factory.createStringLiteral('date'),
+                            inclusive: factory.createTrue(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                default:
+                    throw new Error(`Unsupported ZcDate check: ${check}`);
+            }
+        }
+        yield factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, factory.createBlock([
+            ...checkStmts
+        ], true));
+        yield* ctx.outputs(input);
+    }
+    static{
+        _initClass$o();
+    }
+}
+
+var _dec$n, _initClass$n, _AbstractCompiledType$n;
+let _ZcDefault;
+_dec$n = register(z.ZodFirstPartyTypeKind.ZodDefault);
+class ZcDefault extends (_AbstractCompiledType$n = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcDefault, _initClass$n] } = _(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 factory.createIfStatement(factory.createStrictEquality(factory.createTypeOfExpression(newInput), factory.createStringLiteral('undefined')), factory.createBlock([
+            factory.createExpressionStatement(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' ? factory.createNumericLiteral(status) : status);
+        if (allowShortCircuiting) {
+            if (status === ParseStatus.INVALID) {
+                yield factory.createBreakStatement(this.label);
+            } else if (typeof status !== 'number') {
+                yield factory.createIfStatement(factory.createBitwiseAnd(status, factory.createNumericLiteral(ParseStatus.INVALID)), 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;
+    }
+}
+let _ZcObject;
+_dec$m = register(z.ZodFirstPartyTypeKind.ZodObject);
+class ZcObject extends (_AbstractCompiledType$m = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcObject, _initClass$m] } = _(this, [], [
+            _dec$m
+        ], _AbstractCompiledType$m));
+    }
+    compileType() {
+        return factory.createTypeLiteralNode(Object.entries(this.type._def.shape()).map(([key, value])=>{
+            const type = compilable(value);
+            const isOptional = value._def.typeName === z.ZodFirstPartyTypeKind.ZodOptional || value.isOptional();
+            const node = factory.createPropertySignature(undefined, identifierOrStringLiteral(key), isOptional && value._def.typeName !== z.ZodFirstPartyTypeKind.ZodDefault ? factory.createToken(SyntaxKind.QuestionToken) : undefined, type.compileType());
+            if (value.description) {
+                ts.addSyntheticLeadingComment(node, 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 factory.createIfStatement(factory.createStrictInequality(typeIdentifier, factory.createStringLiteral('object')), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('invalid_type'),
+                    expected: factory.createStringLiteral('object'),
+                    received: typeIdentifier
+                })),
+                ...ctx.status(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, 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 factory.createLabeledStatement(label, 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;
+let _ZcDiscriminatedUnion;
+_dec$l = register(z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion);
+class ZcDiscriminatedUnion extends (_AbstractCompiledType$l = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcDiscriminatedUnion, _initClass$l] } = _(this, [], [
+            _dec$l
+        ], _AbstractCompiledType$l));
+    }
+    compileType() {
+        return 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 factory.createIfStatement(factory.createStrictInequality(typeIdentifier, factory.createStringLiteral('object')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('object'),
+                received: typeIdentifier
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield factory.createSwitchStatement(propertyChain(ctx.input, [
+            this.type._def.discriminator
+        ]), factory.createCaseBlock([
+            ...[
+                ...this.type._def.optionsMap.entries()
+            ].map(([discriminator, zodTy])=>{
+                const ty = compilable(zodTy);
+                if (ty instanceof _ZcObject) {
+                    // We've already checked that the input is an object.
+                    ty.canSkipTypeCheck = true;
+                }
+                return factory.createCaseClause(ctx.dependencies.addOrInline(discriminator), [
+                    ...ty.compileParser(ctx, path),
+                    factory.createBreakStatement()
+                ]);
+            }),
+            factory.createDefaultClause([
+                ...ctx.report(objectLiteral({
+                    path: path.push(this.type._def.discriminator).serialize(),
+                    code: factory.createStringLiteral('invalid_union_discriminator'),
+                    options: ctx.dependencies.add(Array.from(this.type._def.optionsMap.keys()))
+                })),
+                ...ctx.status(ParseStatus.INVALID)
+            ])
+        ]));
+    }
+    static{
+        _initClass$l();
+    }
+}
+
+var _dec$k, _initClass$k, _AbstractCompiledType$k;
+let _ZcEnum;
+_dec$k = register(z.ZodFirstPartyTypeKind.ZodEnum);
+class ZcEnum extends (_AbstractCompiledType$k = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcEnum, _initClass$k] } = _(this, [], [
+            _dec$k
+        ], _AbstractCompiledType$k));
+    }
+    compileType() {
+        return factory.createUnionTypeNode(this.type._def.values.map((ty)=>factory.createLiteralTypeNode(factory.createStringLiteral(ty))));
+    }
+    *compileParser(ctx, path) {
+        const clauses = this.type._def.values.map((value)=>factory.createCaseClause(factory.createStringLiteral(value), []));
+        const lastClause = clauses[clauses.length - 1];
+        clauses[clauses.length - 1] = factory.updateCaseClause(lastClause, lastClause.expression, [
+            ...ctx.outputs(ctx.input),
+            factory.createBreakStatement()
+        ]);
+        yield factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('string')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral(this.type._def.values.map((value)=>`"${value}"`).join(' | ')),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true), factory.createBlock([
+            factory.createSwitchStatement(ctx.input, factory.createCaseBlock([
+                ...clauses,
+                factory.createDefaultClause([
+                    ...ctx.report(objectLiteral({
+                        path: path.serialize(),
+                        code: factory.createStringLiteral('invalid_enum_value'),
+                        options: factory.createArrayLiteralExpression(this.type._def.values.map((value)=>factory.createStringLiteral(value))),
+                        received: ctx.input
+                    })),
+                    ...ctx.status(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' ? factory.createNumericLiteral(status) : status);
+        if (allowShortCircuiting) {
+            if (status === ParseStatus.INVALID) {
+                yield factory.createBreakStatement(this.label);
+            } else if (typeof status !== 'number') {
+                yield factory.createIfStatement(factory.createBitwiseAnd(status, factory.createNumericLiteral(ParseStatus.INVALID)), 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;
+    }
+}
+let _ZcIntersection;
+_dec$j = register(z.ZodFirstPartyTypeKind.ZodIntersection);
+class ZcIntersection extends (_AbstractCompiledType$j = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcIntersection, _initClass$j] } = _(this, [], [
+            _dec$j
+        ], _AbstractCompiledType$j));
+    }
+    compileType() {
+        return 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 factory.createLabeledStatement(label, 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)),
+            factory.createIfStatement(factory.createPropertyAccessExpression(mergeOutput, 'valid'), factory.createBlock([
+                ...ctx.outputs(factory.createPropertyAccessExpression(mergeOutput, 'data'))
+            ], true), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('invalid_intersection_types')
+                })),
+                ...ctx.status(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 factory.createLabeledStatement(label, factory.createBlock([
+            ...compilable(this.type._def[side]).compileParser(childCtx, path)
+        ]));
+    }
+    static{
+        _initClass$j();
+    }
+}
+
+var _dec$i, _initClass$i, _AbstractCompiledType$i;
+let _ZcLiteral;
+_dec$i = register(z.ZodFirstPartyTypeKind.ZodLiteral);
+class ZcLiteral extends (_AbstractCompiledType$i = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcLiteral, _initClass$i] } = _(this, [], [
+            _dec$i
+        ], _AbstractCompiledType$i));
+    }
+    compileType() {
+        const value = this.type._def.value;
+        let n;
+        switch(typeof value){
+            case 'string':
+                n = factory.createStringLiteral(value);
+                break;
+            case 'number':
+                n = factory.createNumericLiteral(value);
+                break;
+            case 'bigint':
+                n = factory.createBigIntLiteral(value.toString());
+                break;
+            case 'undefined':
+                return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
+            case 'boolean':
+                n = value ? factory.createTrue() : factory.createFalse();
+            case 'object':
+                if (value === null) {
+                    n = factory.createNull();
+                }
+            // fallthrough
+            default:
+                throw new Error(`\`zc.ZcLiteral\` only supports primitives (string, number, BigInt, boolean, null, or undefined); got '${typeOf(value)}'`);
+        }
+        return factory.createLiteralTypeNode(n);
+    }
+    *compileParser(ctx, path) {
+        const value = ctx.dependencies.addOrInline(this.type._def.value);
+        yield factory.createIfStatement(factory.createStrictInequality(ctx.input, value), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_literal'),
+                expected: value,
+                received: ctx.input
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass$i();
+    }
+}
+
+var _dec$h, _initClass$h, _AbstractCompiledType$h;
+let _ZcMap;
+_dec$h = register(z.ZodFirstPartyTypeKind.ZodMap);
+class ZcMap extends (_AbstractCompiledType$h = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcMap, _initClass$h] } = _(this, [], [
+            _dec$h
+        ], _AbstractCompiledType$h));
+    }
+    compileType() {
+        const [k, v] = [
+            compilable(this.type._def.keyType),
+            compilable(this.type._def.valueType)
+        ];
+        return factory.createTypeReferenceNode(factory.createIdentifier('Map'), [
+            k.compileType(),
+            v.compileType()
+        ]);
+    }
+    *compileParser(ctx, path) {
+        const typeIdentifier = uniqueIdentifier('type');
+        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
+        yield factory.createIfStatement(factory.createStrictInequality(typeIdentifier, factory.createStringLiteral('map')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('map'),
+                received: typeIdentifier
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        const output = uniqueIdentifier('outputMap');
+        yield local(output, factory.createNewExpression(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 factory.createForOfStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(factory.createArrayBindingPattern([
+                factory.createBindingElement(undefined, undefined, keyInput),
+                factory.createBindingElement(undefined, undefined, valueInput)
+            ]))
+        ], NodeFlags.Const), factory.createCallExpression(factory.createPropertyAccessExpression(ctx.input, 'entries'), undefined, []), factory.createBlock([
+            local(keyOutput, keyInput, true),
+            local(valueOutput, undefined, true),
+            factory.createLabeledStatement(keyLabel, factory.createBlock([
+                ...compilable(this.type._def.keyType).compileParser(keyCtx, path)
+            ])),
+            factory.createLabeledStatement(valueLabel, factory.createBlock([
+                ...compilable(this.type._def.valueType).compileParser(valueCtx, path.push(keyOutput))
+            ])),
+            factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(output, 'set'), undefined, [
+                keyOutput,
+                valueOutput
+            ]))
+        ]));
+        yield* ctx.outputs(output);
+    }
+    static{
+        _initClass$h();
+    }
+}
+
+var _dec$g, _initClass$g, _AbstractCompiledType$g;
+let _ZcNaN;
+_dec$g = register(z.ZodFirstPartyTypeKind.ZodNaN);
+class ZcNaN extends (_AbstractCompiledType$g = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNaN, _initClass$g] } = _(this, [], [
+            _dec$g
+        ], _AbstractCompiledType$g));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createLogicalOr(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('number')), factory.createLogicalNot(factory.createCallExpression(factory.createIdentifier('isNaN'), undefined, [
+            ctx.input
+        ]))), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('nan'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(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))
+    ];
+}
+let _ZcNativeEnum;
+_dec$f = register(z.ZodFirstPartyTypeKind.ZodNativeEnum);
+class ZcNativeEnum extends (_AbstractCompiledType$f = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNativeEnum, _initClass$f] } = _(this, [], [
+            _dec$f
+        ], _AbstractCompiledType$f));
+    }
+    compileType() {
+        return factory.createUnionTypeNode(getValidEnumValues(this.type._def.values).map((value)=>factory.createLiteralTypeNode(typeof value === 'string' ? factory.createStringLiteral(value) : factory.createNumericLiteral(value))));
+    }
+    *compileParser(ctx, path) {
+        const values = getValidEnumValues(this.type._def.values);
+        const clauses = values.map((value)=>factory.createCaseClause(typeof value === 'string' ? factory.createStringLiteral(value) : factory.createNumericLiteral(value), []));
+        const lastClause = clauses[clauses.length - 1];
+        clauses[clauses.length - 1] = factory.updateCaseClause(lastClause, lastClause.expression, [
+            ...ctx.outputs(ctx.input),
+            factory.createBreakStatement()
+        ]);
+        yield factory.createIfStatement(factory.createLogicalAnd(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('string')), factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('number'))), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral(joinValues(values)),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true), factory.createBlock([
+            factory.createSwitchStatement(ctx.input, factory.createCaseBlock([
+                ...clauses,
+                factory.createDefaultClause([
+                    ...ctx.report(objectLiteral({
+                        path: path.serialize(),
+                        code: factory.createStringLiteral('invalid_enum_value'),
+                        options: factory.createArrayLiteralExpression(values.map((value)=>typeof value === 'string' ? factory.createStringLiteral(value) : factory.createNumericLiteral(value))),
+                        received: ctx.input
+                    })),
+                    ...ctx.status(ParseStatus.INVALID)
+                ])
+            ]))
+        ], true));
+    }
+    static{
+        _initClass$f();
+    }
+}
+
+var _dec$e, _initClass$e, _AbstractCompiledType$e;
+let _ZcNever;
+_dec$e = register(z.ZodFirstPartyTypeKind.ZodNever);
+class ZcNever extends (_AbstractCompiledType$e = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNever, _initClass$e] } = _(this, [], [
+            _dec$e
+        ], _AbstractCompiledType$e));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.NeverKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield* ctx.report(objectLiteral({
+            path: path.serialize(),
+            code: factory.createStringLiteral('invalid_type'),
+            expected: factory.createStringLiteral('never'),
+            received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+        }));
+        yield* ctx.status(ParseStatus.INVALID);
+    }
+    static{
+        _initClass$e();
+    }
+}
+
+var _dec$d, _initClass$d, _AbstractCompiledType$d;
+let _ZcNull;
+_dec$d = register(z.ZodFirstPartyTypeKind.ZodNull);
+class ZcNull extends (_AbstractCompiledType$d = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNull, _initClass$d] } = _(this, [], [
+            _dec$d
+        ], _AbstractCompiledType$d));
+    }
+    compileType() {
+        return factory.createLiteralTypeNode(factory.createNull());
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictInequality(ctx.input, factory.createNull()), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('null'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass$d();
+    }
+}
+
+var _dec$c, _initClass$c, _AbstractCompiledType$c;
+let _ZcNullable;
+_dec$c = register(z.ZodFirstPartyTypeKind.ZodNullable);
+class ZcNullable extends (_AbstractCompiledType$c = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNullable, _initClass$c] } = _(this, [], [
+            _dec$c
+        ], _AbstractCompiledType$c));
+    }
+    compileType() {
+        return factory.createUnionTypeNode([
+            compilable(this.type._def.innerType).compileType(),
+            factory.createLiteralTypeNode(factory.createNull())
+        ]);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictEquality(ctx.input, factory.createNull()), factory.createBlock([
+            ...ctx.outputs(factory.createNull())
+        ], true), factory.createBlock([
+            ...compilable(this.type._def.innerType).compileParser(ctx, path)
+        ], true));
+    }
+    static{
+        _initClass$c();
+    }
+}
+
+var _dec$b, _initClass$b, _AbstractCompiledType$b;
+let _ZcNumber;
+_dec$b = register(z.ZodFirstPartyTypeKind.ZodNumber);
+class ZcNumber extends (_AbstractCompiledType$b = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcNumber, _initClass$b] } = _(this, [], [
+            _dec$b
+        ], _AbstractCompiledType$b));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
+    }
+    *compileParser(ctx, path) {
+        let input = ctx.input;
+        if (this.type._def.coerce) {
+            const ident = uniqueIdentifier('coercedInput');
+            yield local(ident, factory.createCallExpression(factory.createIdentifier('Number'), [], [
+                ctx.input
+            ]), false);
+            input = ident;
+        }
+        let stmt = factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(input), factory.createStringLiteral('number')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('number'),
+                received: callHelper(ctx.verifierContext, 'typeOf', input)
+            }), input),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        const checkStmts = [];
+        for (const check of this.type._def.checks){
+            switch(check.kind){
+                case 'min':
+                    checkStmts.push(factory.createIfStatement(factory[check.inclusive ? 'createLessThan' : 'createLessThanEquals'](input, factory.createNumericLiteral(check.value)), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_small'),
+                            minimum: factory.createNumericLiteral(check.value),
+                            type: factory.createStringLiteral('number'),
+                            inclusive: check.inclusive ? factory.createTrue() : factory.createFalse(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'max':
+                    checkStmts.push(factory.createIfStatement(factory[check.inclusive ? 'createGreaterThan' : 'createGreaterThanEquals'](input, factory.createNumericLiteral(check.value)), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('too_big'),
+                            minimum: factory.createNumericLiteral(check.value),
+                            type: factory.createStringLiteral('number'),
+                            inclusive: check.inclusive ? factory.createTrue() : factory.createFalse(),
+                            exact: factory.createFalse(),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'int':
+                    checkStmts.push(factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Number'), 'isInteger'), undefined, [
+                        input
+                    ])), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('invalid_type'),
+                            expected: factory.createStringLiteral('integer'),
+                            received: factory.createStringLiteral('float'),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'finite':
+                    checkStmts.push(factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Number'), 'isFinite'), undefined, [
+                        input
+                    ])), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('not_finite'),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                case 'multipleOf':
+                    checkStmts.push(factory.createIfStatement(factory.createStrictInequality(callHelper(ctx.verifierContext, 'floatSafeRemainder', input, factory.createNumericLiteral(check.value)), factory.createNumericLiteral(0)), factory.createBlock([
+                        ...ctx.report(objectLiteral({
+                            path: path.serialize(),
+                            code: factory.createStringLiteral('not_multiple_of'),
+                            multipleOf: factory.createNumericLiteral(check.value),
+                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                        }), input),
+                        ...ctx.status(ParseStatus.DIRTY)
+                    ], true)));
+                    break;
+                default:
+                    throw new Error(`Unsupported ZcNumber check: ${check}`);
+            }
+        }
+        if (checkStmts.length === 0) {
+            yield stmt;
+        } else {
+            stmt = factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, factory.createBlock([
+                ...checkStmts
+            ], true));
+            yield stmt;
+        }
+        yield* ctx.outputs(input);
+    }
+    static{
+        _initClass$b();
+    }
+}
+
+var _dec$a, _initClass$a, _AbstractCompiledType$a;
+let _ZcOptional;
+_dec$a = register(z.ZodFirstPartyTypeKind.ZodOptional);
+class ZcOptional extends (_AbstractCompiledType$a = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcOptional, _initClass$a] } = _(this, [], [
+            _dec$a
+        ], _AbstractCompiledType$a));
+    }
+    compileType() {
+        return factory.createUnionTypeNode([
+            compilable(this.type._def.innerType).compileType(),
+            factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword)
+        ]);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictEquality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('undefined')), factory.createBlock([
+            ...ctx.outputs(factory.createIdentifier('undefined'))
+        ], true), 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(factory.createCallExpression(propertyChain(factory.createIdentifier('Object'), [
+            'freeze'
+        ]), undefined, [
+            expr
+        ]));
+    }
+}
+let _ZcReadonly;
+_dec$9 = register(z.ZodFirstPartyTypeKind.ZodReadonly);
+class ZcReadonly extends (_AbstractCompiledType$9 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcReadonly, _initClass$9] } = _(this, [], [
+            _dec$9
+        ], _AbstractCompiledType$9));
+    }
+    compileType() {
+        let innerType = compilable(this.type._def.innerType).compileType();
+        if (ts.isArrayTypeNode(innerType)) {
+            return factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, innerType);
+        } else if (ts.isObjectLiteralExpression(innerType) || ts.isUnionTypeNode(innerType) || ts.isIntersectionTypeNode(innerType)) {
+            return factory.createTypeReferenceNode('Readonly', [
+                innerType
+            ]);
+        } else if (ts.isTypeReferenceNode(innerType) && ts.isIdentifier(innerType.typeName)) {
+            switch(innerType.typeName.text){
+                case 'Map':
+                case 'Set':
+                    innerType = factory.updateTypeReferenceNode(innerType, factory.createIdentifier(`Readonly${innerType.typeName.text}`), innerType.typeArguments);
+                    break;
+                case 'Record':
+                    innerType = 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;
+let _ZcRecord;
+_dec$8 = register(z.ZodFirstPartyTypeKind.ZodRecord);
+class ZcRecord extends (_AbstractCompiledType$8 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcRecord, _initClass$8] } = _(this, [], [
+            _dec$8
+        ], _AbstractCompiledType$8));
+    }
+    compileType() {
+        const [k, v] = [
+            compilable(this.type._def.keyType),
+            compilable(this.type._def.valueType)
+        ];
+        return factory.createTypeReferenceNode(factory.createIdentifier('Record'), [
+            k.compileType(),
+            v.compileType()
+        ]);
+    }
+    *compileParser(ctx, path) {
+        const typeIdentifier = uniqueIdentifier('type');
+        yield local(typeIdentifier, callHelper(ctx.verifierContext, 'typeOf', ctx.input));
+        yield factory.createIfStatement(factory.createStrictInequality(typeIdentifier, factory.createStringLiteral('object')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('object'),
+                received: typeIdentifier
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        const output = uniqueIdentifier('outputObject');
+        yield local(output, 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 factory.createForInStatement(factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(keyInput)
+        ], NodeFlags.Const), ctx.input, factory.createBlock([
+            local(keyOutput, keyInput, true),
+            local(valueInput, factory.createElementAccessExpression(ctx.input, keyInput)),
+            local(valueOutput, undefined, true),
+            factory.createLabeledStatement(keyLabel, factory.createBlock([
+                ...compilable(this.type._def.keyType).compileParser(keyCtx, path.push(keyInput))
+            ])),
+            factory.createLabeledStatement(valueLabel, factory.createBlock([
+                ...compilable(this.type._def.valueType).compileParser(valueCtx, path.push(keyOutput))
+            ])),
+            factory.createExpressionStatement(factory.createAssignment(factory.createElementAccessExpression(output, keyOutput), valueOutput))
+        ]));
+        yield* ctx.outputs(output);
+    }
+    static{
+        _initClass$8();
+    }
+}
+
+var _dec$7, _initClass$7, _AbstractCompiledType$7;
+let _ZcSet;
+_dec$7 = register(z.ZodFirstPartyTypeKind.ZodSet);
+class ZcSet extends (_AbstractCompiledType$7 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcSet, _initClass$7] } = _(this, [], [
+            _dec$7
+        ], _AbstractCompiledType$7));
+    }
+    compileType() {
+        return 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 factory.createIfStatement(factory.createStrictInequality(typeIdentifier, factory.createStringLiteral('set')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('set'),
+                received: typeIdentifier
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        if (this.type._def.minSize !== null) {
+            yield factory.createIfStatement(factory.createLessThan(factory.createPropertyAccessExpression(ctx.input, 'size'), factory.createNumericLiteral(this.type._def.minSize.value)), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('too_small'),
+                    minimum: factory.createNumericLiteral(this.type._def.minSize.value),
+                    type: factory.createStringLiteral('set'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createFalse(),
+                    message: this.type._def.minSize.message ? factory.createStringLiteral(this.type._def.minSize.message) : undefined
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        if (this.type._def.maxSize !== null) {
+            yield factory.createIfStatement(factory.createGreaterThan(factory.createPropertyAccessExpression(ctx.input, 'size'), factory.createNumericLiteral(this.type._def.maxSize.value)), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('too_big'),
+                    minimum: factory.createNumericLiteral(this.type._def.maxSize.value),
+                    type: factory.createStringLiteral('set'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createFalse(),
+                    message: this.type._def.maxSize.message ? factory.createStringLiteral(this.type._def.maxSize.message) : undefined
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        const output = uniqueIdentifier('outputSet');
+        yield local(output, factory.createNewExpression(factory.createIdentifier('Set'), undefined, []));
+        const indexInitializer = 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 factory.createForOfStatement(undefined, factory.createVariableDeclarationList([
+            factory.createVariableDeclaration(factory.createArrayBindingPattern([
+                factory.createBindingElement(undefined, undefined, indexInitializer),
+                factory.createBindingElement(undefined, undefined, elInitializer)
+            ]))
+        ], NodeFlags.Const), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createArrayLiteralExpression([
+            factory.createSpreadElement(factory.createCallExpression(factory.createPropertyAccessExpression(ctx.input, 'values'), undefined, []))
+        ]), 'entries'), undefined, undefined), factory.createBlock([
+            ...childCtx.prelude(),
+            local(elOutput, undefined, true),
+            ...compilable(this.type._def.valueType).compileParser(childCtx, path.push(indexInitializer)),
+            ...childCtx.postlude(),
+            factory.createExpressionStatement(factory.createCallExpression(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}$/`;
+}
+let _ZcString;
+_dec$6 = register(z.ZodFirstPartyTypeKind.ZodString);
+new class extends _$1 {
+    constructor(){
+        super(_ZcString), _initClass$6();
+    }
+    static{
+        class ZcString extends (_AbstractCompiledType$6 = AbstractCompiledType) {
+            static{
+                ({ c: [_ZcString, _initClass$6] } = _(this, [], [
+                    _dec$6
+                ], _AbstractCompiledType$6));
+            }
+            compileType() {
+                return factory.createKeywordTypeNode(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, factory.createCallExpression(factory.createIdentifier('String'), [], [
+                        ctx.input
+                    ]), hasModifyingChecks);
+                    input = ident;
+                } else if (hasModifyingChecks) {
+                    const ident = uniqueIdentifier('input');
+                    yield local(ident, input, true);
+                    input = ident;
+                }
+                let stmt = factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(input), factory.createStringLiteral('string')), factory.createBlock([
+                    ...ctx.report(objectLiteral({
+                        path: path.serialize(),
+                        code: factory.createStringLiteral('invalid_type'),
+                        expected: factory.createStringLiteral('string'),
+                        received: callHelper(ctx.verifierContext, 'typeOf', input)
+                    }), input),
+                    ...ctx.status(ParseStatus.INVALID)
+                ], true));
+                const checkStmts = [];
+                for (const check of this.type._def.checks){
+                    switch(check.kind){
+                        case 'min':
+                            checkStmts.push(factory.createIfStatement(factory.createLessThan(propertyChain(input, [
+                                'length'
+                            ]), factory.createNumericLiteral(check.value)), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('too_small'),
+                                    minimum: factory.createNumericLiteral(check.value),
+                                    type: factory.createStringLiteral('string'),
+                                    inclusive: factory.createTrue(),
+                                    exact: factory.createFalse(),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)));
+                            break;
+                        case 'max':
+                            checkStmts.push(factory.createIfStatement(factory.createGreaterThan(propertyChain(input, [
+                                'length'
+                            ]), factory.createNumericLiteral(check.value)), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('too_big'),
+                                    minimum: factory.createNumericLiteral(check.value),
+                                    type: factory.createStringLiteral('string'),
+                                    inclusive: factory.createTrue(),
+                                    exact: factory.createFalse(),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)));
+                            break;
+                        case 'length':
+                            const value = factory.createNumericLiteral(check.value);
+                            const lengthAccessor = factory.createPropertyAccessExpression(ctx.input, 'length');
+                            const tooBigIdent = uniqueIdentifier('tooBig');
+                            const tooSmallIdent = uniqueIdentifier('tooSmall');
+                            checkStmts.push(factory.createIfStatement(factory.createStrictInequality(lengthAccessor, value), factory.createBlock([
+                                local(tooBigIdent, factory.createGreaterThan(lengthAccessor, value)),
+                                local(tooSmallIdent, factory.createLessThan(lengthAccessor, value)),
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createConditionalExpression(tooBigIdent, undefined, factory.createStringLiteral('too_big'), undefined, factory.createStringLiteral('too_small')),
+                                    minimum: factory.createConditionalExpression(tooSmallIdent, undefined, value, undefined, factory.createIdentifier('undefined')),
+                                    maximum: factory.createConditionalExpression(tooBigIdent, undefined, value, undefined, factory.createIdentifier('undefined')),
+                                    type: factory.createStringLiteral('string'),
+                                    inclusive: factory.createTrue(),
+                                    exact: factory.createTrue(),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(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, factory.createRegularExpressionLiteral(check.regex.toString()), check.kind, check.message));
+                            break;
+                        case 'datetime':
+                            {
+                                const regex = factory.createRegularExpressionLiteral(createDatetimeRegex(check));
+                                checkStmts.push(ZcString._basicCheck(ctx, path, input, regex, check.kind, check.message));
+                                break;
+                            }
+                        case 'time':
+                            {
+                                const regex = 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(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalNot(factory.createCallExpression(propertyChain(ctx.verifierContext, [
+                                        'regex',
+                                        `IPV4${cidrSuffix}`,
+                                        'test'
+                                    ]), undefined, [
+                                        input
+                                    ])), factory.createLogicalNot(factory.createCallExpression(propertyChain(ctx.verifierContext, [
+                                        'regex',
+                                        `IPV6${cidrSuffix}`,
+                                        'test'
+                                    ]), undefined, [
+                                        input
+                                    ]))), factory.createBlock([
+                                        ...ctx.report(objectLiteral({
+                                            path: path.serialize(),
+                                            code: factory.createStringLiteral('invalid_string'),
+                                            validation: factory.createStringLiteral(check.kind),
+                                            message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                        }), input),
+                                        ...ctx.status(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(factory.createTryStatement(factory.createBlock([
+                                factory.createExpressionStatement(factory.createNewExpression(factory.createIdentifier('URL'), undefined, [
+                                    input
+                                ]))
+                            ], true), factory.createCatchClause(uniqueIdentifier('e'), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('invalid_string'),
+                                    validation: factory.createStringLiteral('url'),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)), undefined));
+                            break;
+                        case 'jwt':
+                            checkStmts.push(factory.createIfStatement(factory.createLogicalNot(callHelper(ctx.verifierContext, 'isValidJWT', input, check.alg ? factory.createStringLiteral(check.alg) : factory.createIdentifier('undefined'))), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('invalid_string'),
+                                    validation: factory.createStringLiteral('url'),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)));
+                            break;
+                        case 'startsWith':
+                        case 'endsWith':
+                            checkStmts.push(factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(input, check.kind), undefined, [
+                                factory.createStringLiteral(check.value)
+                            ])), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('invalid_string'),
+                                    validation: objectLiteral({
+                                        [check.kind]: factory.createStringLiteral(check.value)
+                                    }),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)));
+                            break;
+                        case 'includes':
+                            checkStmts.push(factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(input, 'includes'), undefined, [
+                                factory.createStringLiteral(check.value),
+                                check.position ? factory.createNumericLiteral(check.position) : factory.createIdentifier('undefined')
+                            ])), factory.createBlock([
+                                ...ctx.report(objectLiteral({
+                                    path: path.serialize(),
+                                    code: factory.createStringLiteral('invalid_string'),
+                                    validation: objectLiteral({
+                                        includes: factory.createStringLiteral(check.value),
+                                        position: check.position ? factory.createNumericLiteral(check.position) : undefined
+                                    }),
+                                    message: check.message ? factory.createStringLiteral(check.message) : undefined
+                                }), input),
+                                ...ctx.status(ParseStatus.DIRTY)
+                            ], true)));
+                            break;
+                        case 'trim':
+                        case 'toLowerCase':
+                        case 'toUpperCase':
+                            {
+                                checkStmts.push(factory.createExpressionStatement(factory.createAssignment(input, factory.createCallExpression(factory.createPropertyAccessExpression(input, check.kind), undefined, []))));
+                                break;
+                            }
+                        default:
+                            throw new Error(`Unsupported ZcString check: ${check}`);
+                    }
+                }
+                if (checkStmts.length === 0) {
+                    yield stmt;
+                } else {
+                    stmt = factory.updateIfStatement(stmt, stmt.expression, stmt.thenStatement, 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.isRegularExpressionLiteral(regexOrTester) ? factory.createPropertyAccessExpression(regexOrTester, 'test') : regexOrTester;
+                return factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(testFunction, undefined, [
+                    input
+                ])), factory.createBlock([
+                    ...ctx.report(objectLiteral({
+                        path: path.serialize(),
+                        code: factory.createStringLiteral('invalid_string'),
+                        validation: factory.createStringLiteral(checkKind),
+                        message: message ? factory.createStringLiteral(message) : undefined
+                    }), input),
+                    ...ctx.status(ParseStatus.DIRTY)
+                ], true));
+            }
+        }
+    }
+}();
+
+var _dec$5, _initClass$5, _AbstractCompiledType$5;
+let _ZcSymbol;
+_dec$5 = register(z.ZodFirstPartyTypeKind.ZodSymbol);
+class ZcSymbol extends (_AbstractCompiledType$5 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcSymbol, _initClass$5] } = _(this, [], [
+            _dec$5
+        ], _AbstractCompiledType$5));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.SymbolKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('symbol')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('symbol'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass$5();
+    }
+}
+
+var _dec$4, _initClass$4, _AbstractCompiledType$4;
+let _ZcTuple;
+_dec$4 = register(z.ZodFirstPartyTypeKind.ZodTuple);
+class ZcTuple extends (_AbstractCompiledType$4 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcTuple, _initClass$4] } = _(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(factory.createRestTypeNode(compilable(this.type._def.rest).compileType()));
+        }
+        return factory.createTupleTypeNode(items);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Array'), 'isArray'), undefined, [
+            ctx.input
+        ])), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('array'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield factory.createIfStatement(factory.createLessThan(factory.createPropertyAccessExpression(ctx.input, 'length'), factory.createNumericLiteral(this.type._def.items.length)), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('too_small'),
+                minimum: factory.createNumericLiteral(this.type._def.items.length),
+                type: factory.createStringLiteral('array'),
+                inclusive: factory.createTrue(),
+                exact: factory.createFalse()
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        if (!this.type._def.rest) {
+            yield factory.createIfStatement(factory.createGreaterThan(factory.createPropertyAccessExpression(ctx.input, 'length'), factory.createNumericLiteral(this.type._def.items.length)), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('too_big'),
+                    minimum: factory.createNumericLiteral(this.type._def.items.length),
+                    type: factory.createStringLiteral('array'),
+                    inclusive: factory.createTrue(),
+                    exact: factory.createFalse()
+                })),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true));
+        }
+        const output = uniqueIdentifier('outputTuple');
+        yield local(output, factory.createNewExpression(factory.createIdentifier('Array'), undefined, [
+            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 factory.createLabeledStatement(label, factory.createBlock([
+                ...compilable(ty).compileParser(childCtx, path.push(i))
+            ]));
+        }
+        if (this.type._def.rest) {
+            const indexInitializer = factory.createLoopVariable(true);
+            const elInitializer = uniqueIdentifier('el');
+            const elOutput = factory.createElementAccessExpression(output, indexInitializer);
+            const childCtx = new ArrayGeneratorContext(elInitializer, elOutput, ctx.verifierContext, ctx.dependencies, (status)=>ctx.status(status, false));
+            yield factory.createForStatement(local(indexInitializer, factory.createNumericLiteral(this.type._def.items.length), true).declarationList, factory.createLessThan(indexInitializer, factory.createPropertyAccessExpression(ctx.input, 'length')), factory.createPostfixIncrement(indexInitializer), factory.createBlock([
+                local(elInitializer, 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;
+let _ZcUndefined;
+_dec$3 = register(z.ZodFirstPartyTypeKind.ZodUndefined);
+class ZcUndefined extends (_AbstractCompiledType$3 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcUndefined, _initClass$3] } = _(this, [], [
+            _dec$3
+        ], _AbstractCompiledType$3));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('undefined')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('undefined'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(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 factory.createIfStatement(factory.createStrictEquality(this.statusVar, factory.createNumericLiteral(ParseStatus.VALID)), factory.createBlock([
+            ...this.parent.ctx.outputs(this.output),
+            factory.createBreakStatement(this.parent.label)
+        ], true), factory.createIfStatement(factory.createLogicalAnd(factory.createStrictEquality(this.statusVar, factory.createNumericLiteral(ParseStatus.DIRTY)), factory.createLogicalNot(this.parent.dirtyResultVar)), factory.createBlock([
+            factory.createExpressionStatement(factory.createAssignment(this.parent.dirtyResultVar, this.output)),
+            factory.createExpressionStatement(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 = factory.createPropertyAccessExpression(this.verifierContext, 'issues');
+        yield factory.createIfStatement(factory.createPropertyAccessExpression(childIssues, 'length'), factory.createBlock([
+            factory.createExpressionStatement(factory.createCallExpression(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;
+    }
+}
+let _ZcUnion;
+_dec$2 = register(z.ZodFirstPartyTypeKind.ZodUnion);
+class ZcUnion extends (_AbstractCompiledType$2 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcUnion, _initClass$2] } = _(this, [], [
+            _dec$2
+        ], _AbstractCompiledType$2));
+    }
+    compileType() {
+        return 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, factory.createArrayLiteralExpression(), false);
+        const mainLabel = uniqueIdentifier('union');
+        yield factory.createLabeledStatement(mainLabel, 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, factory.createObjectLiteralExpression([
+                        factory.createSpreadAssignment(ctx.verifierContext),
+                        factory.createPropertyAssignment('issues', 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 factory.createLabeledStatement(variantLabel, factory.createBlock([
+                        ...ty.compileParser(childCtx, path)
+                    ], true));
+                    yield* childCtx.postlude();
+                }
+                return [
+                    ...generateBody()
+                ];
+            }),
+            factory.createIfStatement(dirtyCtxVar, factory.createBlock([
+                ...ctx.report(factory.createSpreadElement(factory.createPropertyAccessExpression(dirtyCtxVar, 'issues'))),
+                ...ctx.status(ParseStatus.DIRTY)
+            ], true), factory.createBlock([
+                ...ctx.report(objectLiteral({
+                    path: path.serialize(),
+                    code: factory.createStringLiteral('invalid_union'),
+                    unionErrors: factory.createCallExpression(factory.createPropertyAccessExpression(issuesVar, 'map'), undefined, [
+                        factory.createArrowFunction(undefined, undefined, [
+                            factory.createParameterDeclaration(undefined, undefined, 'issues')
+                        ], undefined, undefined, factory.createNewExpression(factory.createPropertyAccessExpression(ctx.verifierContext, 'ZcError'), undefined, [
+                            factory.createIdentifier('issues')
+                        ]))
+                    ])
+                })),
+                ...ctx.status(ParseStatus.INVALID)
+            ], true))
+        ]));
+    }
+    static{
+        _initClass$2();
+    }
+}
+
+var _dec$1, _initClass$1, _AbstractCompiledType$1;
+let _ZcUnknown;
+_dec$1 = register(z.ZodFirstPartyTypeKind.ZodUnknown);
+class ZcUnknown extends (_AbstractCompiledType$1 = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcUnknown, _initClass$1] } = _(this, [], [
+            _dec$1
+        ], _AbstractCompiledType$1));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass$1();
+    }
+}
+
+var _dec, _initClass, _AbstractCompiledType;
+let _ZcVoid;
+_dec = register(z.ZodFirstPartyTypeKind.ZodVoid);
+class ZcVoid extends (_AbstractCompiledType = AbstractCompiledType) {
+    static{
+        ({ c: [_ZcVoid, _initClass] } = _(this, [], [
+            _dec
+        ], _AbstractCompiledType));
+    }
+    compileType() {
+        return factory.createKeywordTypeNode(SyntaxKind.VoidKeyword);
+    }
+    *compileParser(ctx, path) {
+        yield factory.createIfStatement(factory.createStrictInequality(factory.createTypeOfExpression(ctx.input), factory.createStringLiteral('undefined')), factory.createBlock([
+            ...ctx.report(objectLiteral({
+                path: path.serialize(),
+                code: factory.createStringLiteral('invalid_type'),
+                expected: factory.createStringLiteral('undefined'),
+                received: callHelper(ctx.verifierContext, 'typeOf', ctx.input)
+            })),
+            ...ctx.status(ParseStatus.INVALID)
+        ], true));
+        yield* ctx.outputs(ctx.input);
+    }
+    static{
+        _initClass();
+    }
+}
+
+function compile(schema, options) {
+    const type = compilable(schema);
+    const verifierContext = factory.createIdentifier('ctx');
+    const dependencies = new Dependencies(verifierContext, options?.inlining ?? InliningMode.Default);
+    const ctx = new FunctionalGeneratorContext(factory.createIdentifier('input'), propertyChain(factory.createIdentifier('ctx'), [
+        'output'
+    ]), verifierContext, dependencies);
+    const functionBody = [
+        ...ctx.prelude(),
+        ...type.compileParser(ctx, Path.empty()),
+        ...ctx.postlude()
+    ];
+    if (options?.standalone) {
+        return {
+            source: print(factory.createFunctionExpression(undefined, undefined, undefined, undefined, [
+                factory.createParameterDeclaration(undefined, undefined, 'input'),
+                factory.createParameterDeclaration(undefined, undefined, 'ctx')
+            ], undefined, factory.createBlock(functionBody, true))),
+            dependencies: dependencies.dependencies,
+            get hasDependencies () {
+                return dependencies.dependencies.length > 0;
+            }
+        };
+    }
+    const sourceFile = factory.createSourceFile(functionBody, factory.createToken(SyntaxKind.EndOfFileToken), 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(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(factory.createSourceFile([
+            factory.createTypeAliasDeclaration([
+                factory.createToken(SyntaxKind.ExportKeyword)
+            ], options?.schemaName ?? 'Schema', undefined, typeDef)
+        ], factory.createToken(SyntaxKind.EndOfFileToken), NodeFlags.None));
+    } else {
+        return print(typeDef);
+    }
+}
+
+var zc = {
+	__proto__: null,
+	AbstractCompiledType: AbstractCompiledType,
+	InliningMode: InliningMode,
+	get ZcAny () { return _ZcAny; },
+	get ZcArray () { return _ZcArray; },
+	get ZcBigInt () { return _ZcBigInt; },
+	get ZcBoolean () { return _ZcBoolean; },
+	get ZcBranded () { return _ZcBranded; },
+	get ZcCatch () { return _ZcCatch; },
+	get ZcDate () { return _ZcDate; },
+	get ZcDefault () { return _ZcDefault; },
+	get ZcDiscriminatedUnion () { return _ZcDiscriminatedUnion; },
+	get ZcEnum () { return _ZcEnum; },
+	ZcError: ZcError,
+	get ZcIntersection () { return _ZcIntersection; },
+	get ZcLiteral () { return _ZcLiteral; },
+	get ZcMap () { return _ZcMap; },
+	get ZcNaN () { return _ZcNaN; },
+	get ZcNativeEnum () { return _ZcNativeEnum; },
+	get ZcNever () { return _ZcNever; },
+	get ZcNull () { return _ZcNull; },
+	get ZcNullable () { return _ZcNullable; },
+	get ZcNumber () { return _ZcNumber; },
+	get ZcObject () { return _ZcObject; },
+	get ZcOptional () { return _ZcOptional; },
+	get ZcReadonly () { return _ZcReadonly; },
+	get ZcRecord () { return _ZcRecord; },
+	get ZcSet () { return _ZcSet; },
+	get ZcString () { return _ZcString; },
+	get ZcSymbol () { return _ZcSymbol; },
+	get ZcTuple () { return _ZcTuple; },
+	get ZcUndefined () { return _ZcUndefined; },
+	get ZcUnion () { return _ZcUnion; },
+	get ZcUnknown () { return _ZcUnknown; },
+	get ZcVoid () { return _ZcVoid; },
+	compilable: compilable,
+	compile: compile,
+	types: types
+};
+
+export { AbstractCompiledType, InliningMode, _ZcAny as ZcAny, _ZcArray as ZcArray, _ZcBigInt as ZcBigInt, _ZcBoolean as ZcBoolean, _ZcBranded as ZcBranded, _ZcCatch as ZcCatch, _ZcDate as ZcDate, _ZcDefault as ZcDefault, _ZcDiscriminatedUnion as ZcDiscriminatedUnion, _ZcEnum as ZcEnum, ZcError, _ZcIntersection as ZcIntersection, _ZcLiteral as ZcLiteral, _ZcMap as ZcMap, _ZcNaN as ZcNaN, _ZcNativeEnum as ZcNativeEnum, _ZcNever as ZcNever, _ZcNull as ZcNull, _ZcNullable as ZcNullable, _ZcNumber as ZcNumber, _ZcObject as ZcObject, _ZcOptional as ZcOptional, _ZcReadonly as ZcReadonly, _ZcRecord as ZcRecord, _ZcSet as ZcSet, _ZcString as ZcString, _ZcSymbol as ZcSymbol, _ZcTuple as ZcTuple, _ZcUndefined as ZcUndefined, _ZcUnion as ZcUnion, _ZcUnknown as ZcUnknown, _ZcVoid as ZcVoid, compilable, compile, zc as default, types };