@livon/schema 0.27.0-rc.1

package/dist/or.spec.cjs

@@ -0,0 +1,204 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_or_cjs_namespaceObject = require("./or.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const buildContextMock = {
+    buildId: 'build-or',
+    builder: {
+        add: external_vitest_namespaceObject.vi.fn((node)=>node),
+        getAll: external_vitest_namespaceObject.vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)({
+    buildContext: buildContextMock
+});
+const firstOptionMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'firstOption',
+    parse: external_vitest_namespaceObject.vi.fn(()=>{
+        throw {
+            code: 'first.fail'
+        };
+    }),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'FirstOption'
+        }))
+});
+const secondOptionMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'secondOption',
+    parse: external_vitest_namespaceObject.vi.fn(()=>2),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'number',
+            name: 'SecondOption'
+        }))
+});
+const unknownOptionMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'unknownOption',
+    parse: external_vitest_namespaceObject.vi.fn(()=>'unknown'),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'UnknownOption'
+        }))
+});
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('or()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockReset();
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockImplementation(()=>{
+            throw {
+                code: 'first.fail'
+            };
+        });
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.ast).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockReset();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockReturnValue(2);
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.ast).mockClear();
+        external_vitest_namespaceObject.vi.mocked(unknownOptionMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(unknownOptionMock.ast).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when or schema is created', ()=>{
+            const result = (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Selector');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('or');
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should build ast from options when build context is available', ()=>{
+            (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ast).toEqual({
+                type: 'union',
+                name: 'Selector',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'FirstOption'
+                    },
+                    {
+                        type: 'number',
+                        name: 'SecondOption'
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(firstOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should fall back to option matching when discriminator is missing', ()=>{
+            (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(2);
+            (0, external_vitest_namespaceObject.expect)(firstOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should use discriminator option when discriminator returns known schema', ()=>{
+            const discriminator = external_vitest_namespaceObject.vi.fn(()=>secondOptionMock);
+            (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ],
+                discriminator
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(2);
+            (0, external_vitest_namespaceObject.expect)(discriminator).toHaveBeenCalledWith('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(firstOptionMock.parse).not.toHaveBeenCalled();
+            (0, external_vitest_namespaceObject.expect)(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw or.discriminator when discriminator returns unknown schema', ()=>{
+            const discriminator = external_vitest_namespaceObject.vi.fn(()=>unknownOptionMock);
+            (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ],
+                discriminator
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('input', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Discriminator selected an unknown schema option.',
+                code: 'or.discriminator'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw union.match when no option matches', ()=>{
+            external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockImplementation(()=>{
+                throw {
+                    code: 'second.fail'
+                };
+            });
+            (0, external_or_cjs_namespaceObject.or)({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('input', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'No union match',
+                code: 'union.match'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/or.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/or.spec.js

@@ -0,0 +1,198 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { or } from "./or.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const buildContextMock = {
+    buildId: 'build-or',
+    builder: {
+        add: vi.fn((node)=>node),
+        getAll: vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = createSchemaContextMock({
+    buildContext: buildContextMock
+});
+const firstOptionMock = createBaseSchemaMock({
+    name: 'firstOption',
+    parse: vi.fn(()=>{
+        throw {
+            code: 'first.fail'
+        };
+    }),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'FirstOption'
+        }))
+});
+const secondOptionMock = createBaseSchemaMock({
+    name: 'secondOption',
+    parse: vi.fn(()=>2),
+    ast: vi.fn(()=>({
+            type: 'number',
+            name: 'SecondOption'
+        }))
+});
+const unknownOptionMock = createBaseSchemaMock({
+    name: 'unknownOption',
+    parse: vi.fn(()=>'unknown'),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'UnknownOption'
+        }))
+});
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('or()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        vi.mocked(firstOptionMock.parse).mockReset();
+        vi.mocked(firstOptionMock.parse).mockImplementation(()=>{
+            throw {
+                code: 'first.fail'
+            };
+        });
+        vi.mocked(firstOptionMock.ast).mockClear();
+        vi.mocked(secondOptionMock.parse).mockReset();
+        vi.mocked(secondOptionMock.parse).mockReturnValue(2);
+        vi.mocked(secondOptionMock.ast).mockClear();
+        vi.mocked(unknownOptionMock.parse).mockClear();
+        vi.mocked(unknownOptionMock.ast).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(firstOptionMock.parse).mockClear();
+        vi.mocked(secondOptionMock.parse).mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when or schema is created', ()=>{
+            const result = or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Selector');
+            expect(factoryInput.type).toBe('or');
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should build ast from options when build context is available', ()=>{
+            or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            expect(ast).toEqual({
+                type: 'union',
+                name: 'Selector',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'FirstOption'
+                    },
+                    {
+                        type: 'number',
+                        name: 'SecondOption'
+                    }
+                ]
+            });
+            expect(firstOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+            expect(secondOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        it('should fall back to option matching when discriminator is missing', ()=>{
+            or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            expect(parsed).toBe(2);
+            expect(firstOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+            expect(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+        it('should use discriminator option when discriminator returns known schema', ()=>{
+            const discriminator = vi.fn(()=>secondOptionMock);
+            or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ],
+                discriminator
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            expect(parsed).toBe(2);
+            expect(discriminator).toHaveBeenCalledWith('input', schemaContextMock);
+            expect(firstOptionMock.parse).not.toHaveBeenCalled();
+            expect(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw or.discriminator when discriminator returns unknown schema', ()=>{
+            const discriminator = vi.fn(()=>unknownOptionMock);
+            or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ],
+                discriminator
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('input', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Discriminator selected an unknown schema option.',
+                code: 'or.discriminator'
+            });
+        });
+        it('should throw union.match when no option matches', ()=>{
+            vi.mocked(secondOptionMock.parse).mockImplementation(()=>{
+                throw {
+                    code: 'second.fail'
+                };
+            });
+            or({
+                name: 'Selector',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('input', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'No union match',
+                code: 'union.match'
+            });
+        });
+    });
+});

package/dist/schema.cjs

@@ -0,0 +1,285 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    fail: ()=>fail,
+    createPrimitiveSchema: ()=>createPrimitiveSchema,
+    createIssueForPath: ()=>createIssueForPath,
+    ok: ()=>ok,
+    createGuardSchema: ()=>createGuardSchema,
+    createSchema: ()=>createSchema,
+    ensureSchemaContext: ()=>ensureSchemaContext
+});
+const external_SchemaValidationError_cjs_namespaceObject = require("./SchemaValidationError.cjs");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_doc_cjs_namespaceObject = require("./doc.cjs");
+const createIssueForPath = ({ path, message, code, context })=>({
+        path,
+        message,
+        code,
+        context
+    });
+const ok = ({ value })=>({
+        ok: true,
+        value
+    });
+const fail = ({ issues, meta })=>({
+        ok: false,
+        issues,
+        meta
+    });
+const ensureSchemaContext = (ctx)=>{
+    if (ctx) return ctx;
+    const request = (0, external_context_cjs_namespaceObject.normalizeRequestContext)();
+    return (0, external_context_cjs_namespaceObject.createSchemaContext)({
+        request
+    });
+};
+const createSchema = ({ name, type, ast, validate })=>{
+    const validateWithContext = (input, ctx)=>{
+        const context = ensureSchemaContext(ctx);
+        if (!context.getRequestContext()) context.setRequestContext((0, external_context_cjs_namespaceObject.normalizeRequestContext)());
+        const build = context.getBuildContext();
+        const request = context.getRequestContext();
+        const meta = {
+            build,
+            request,
+            type,
+            name
+        };
+        const result = validate(input, context);
+        return result.ok ? result : fail({
+            issues: result.issues,
+            meta
+        });
+    };
+    const parse = (input, ctx)=>{
+        const result = validateWithContext(input, ctx);
+        if (result.ok) return result.value;
+        throw (0, external_SchemaValidationError_cjs_namespaceObject.createSchemaValidationError)({
+            issues: result.issues,
+            meta: result.meta
+        });
+    };
+    const typed = (input, ctx)=>parse(input, ctx);
+    const optional = ()=>createSchema({
+            name: `${name}.optional`,
+            type: `${type}.optional`,
+            ast,
+            validate: (input, ctx)=>void 0 === input ? ok({
+                    value: void 0
+                }) : validate(input, ctx)
+        });
+    const nullable = ()=>createSchema({
+            name: `${name}.nullable`,
+            type: `${type}.nullable`,
+            ast,
+            validate: (input, ctx)=>null === input ? ok({
+                    value: null
+                }) : validate(input, ctx)
+        });
+    const describe = (doc)=>{
+        const nextDoc = (0, external_doc_cjs_namespaceObject.normalizeDoc)(doc);
+        return createSchema({
+            name,
+            type,
+            ast: (ctx)=>{
+                const node = ast(ctx);
+                const merged = (0, external_doc_cjs_namespaceObject.mergeDoc)(node.doc, nextDoc);
+                return merged ? {
+                    ...node,
+                    doc: merged
+                } : node;
+            },
+            validate
+        });
+    };
+    const refine = ({ predicate, message, code })=>createSchema({
+            name: `${name}.refine`,
+            type: `${type}.refine`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = validate(input, context);
+                if (!result.ok) return result;
+                return predicate(result.value, context) ? result : fail({
+                    issues: [
+                        createIssueForPath({
+                            path: [],
+                            message,
+                            code
+                        })
+                    ]
+                });
+            }
+        });
+    const before = (hook)=>createSchema({
+            name: `${name}.before`,
+            type: `${type}.before`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = hook(input, context);
+                const issues = 'object' == typeof result && null !== result && 'issues' in result ? result.issues ?? [] : [];
+                if (issues.length > 0) return fail({
+                    issues
+                });
+                const nextInput = 'object' == typeof result && null !== result && 'input' in result ? result.input : result;
+                return validate(nextInput, context);
+            }
+        });
+    const after = (hook)=>createSchema({
+            name: `${name}.after`,
+            type: `${type}.after`,
+            ast,
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const result = validate(input, context);
+                if (!result.ok) return result;
+                const hookResult = hook(result.value, context);
+                const issues = 'object' == typeof hookResult && null !== hookResult && 'issues' in hookResult ? hookResult.issues ?? [] : [];
+                if (issues.length > 0) return fail({
+                    issues
+                });
+                const nextValue = 'object' == typeof hookResult && null !== hookResult && 'value' in hookResult ? hookResult.value : hookResult;
+                return ok({
+                    value: nextValue
+                });
+            }
+        });
+    const and = (other)=>createSchema({
+            name: `${name}.and`,
+            type: `${type}.and`,
+            ast: (ctx)=>({
+                    type: 'and',
+                    children: [
+                        ast(ctx),
+                        other.ast(ctx.getBuildContext())
+                    ]
+                }),
+            validate: (input, ctx)=>{
+                const context = ensureSchemaContext(ctx);
+                const left = validate(input, context);
+                const right = other.validate(input, context);
+                return left.ok && right.ok ? ok({
+                    value: left.value
+                }) : fail({
+                    issues: [
+                        ...left.ok ? [] : left.issues,
+                        ...right.ok ? [] : right.issues
+                    ]
+                });
+            }
+        });
+    const resolveAst = (ctx)=>{
+        const node = ast(ctx);
+        return node.name ? node : {
+            ...node,
+            name
+        };
+    };
+    return {
+        name,
+        type,
+        ast: (input)=>{
+            const build = (0, external_context_cjs_namespaceObject.normalizeBuildContext)(input ?? {});
+            const context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                build
+            });
+            return resolveAst(context);
+        },
+        validate: validateWithContext,
+        parse,
+        typed,
+        optional,
+        nullable,
+        describe,
+        refine,
+        before,
+        after,
+        and
+    };
+};
+const createGuardSchema = ({ name, type, guard, message, code })=>createSchema({
+        name,
+        type,
+        ast: ()=>({
+                type,
+                constraints: {
+                    kind: 'guard'
+                }
+            }),
+        validate: (input)=>guard(input) ? ok({
+                value: input
+            }) : fail({
+                issues: [
+                    createIssueForPath({
+                        path: [],
+                        message,
+                        code
+                    })
+                ]
+            })
+    });
+const createPrimitiveSchema = ({ name, type, guard, message, code })=>createSchema({
+        name,
+        type,
+        ast: ()=>({
+                type,
+                constraints: {
+                    kind: 'primitive'
+                }
+            }),
+        validate: (input)=>guard(input) ? ok({
+                value: input
+            }) : fail({
+                issues: [
+                    createIssueForPath({
+                        path: [],
+                        message,
+                        code
+                    })
+                ]
+            })
+    });
+exports.createGuardSchema = __webpack_exports__.createGuardSchema;
+exports.createIssueForPath = __webpack_exports__.createIssueForPath;
+exports.createPrimitiveSchema = __webpack_exports__.createPrimitiveSchema;
+exports.createSchema = __webpack_exports__.createSchema;
+exports.ensureSchemaContext = __webpack_exports__.ensureSchemaContext;
+exports.fail = __webpack_exports__.fail;
+exports.ok = __webpack_exports__.ok;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createGuardSchema",
+    "createIssueForPath",
+    "createPrimitiveSchema",
+    "createSchema",
+    "ensureSchemaContext",
+    "fail",
+    "ok"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});