@reforma/components 0.1.6 → 0.2.1

package/dist/node_modules/zod/v4/core/memoizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoizer.js","sources":["../../../../../../../node_modules/zod/v4/core/memoizer.js"],"sourcesContent":["import * as util from \"./util.js\";\nexport class $ZodCyclicError extends Error {\n    constructor() {\n        super(`Cannot parse a reference cycle that closes through a transform`);\n        this.name = \"ZodCyclicError\";\n    }\n}\n/** Keyed off the context object every schema in one parse call already shares. */\nconst STATE = \"~memo\";\nconst NO_ISSUES = [];\n// a value a cycle can close through\nfunction isRef(value) {\n    return value !== null && typeof value === \"object\";\n}\n// Receivers prefix paths in place, so the cache and every hand-out need their own copies.\nfunction cloneIssues(issues) {\n    return issues.map((iss) => (iss.path ? { ...iss, path: iss.path.slice() } : { ...iss }));\n}\nconst recursive = /*@__PURE__*/ new WeakMap();\n/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */\nconst NONE = 0;\nconst ASSUMED = 1;\nconst PROVEN = 2;\n/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */\nfunction isRecursive(inst, stack, resolve) {\n    const cached = recursive.get(inst);\n    if (cached !== undefined)\n        return cached ? PROVEN : NONE;\n    // Relative to the walk in progress, so not cached.\n    if (stack.has(inst))\n        return PROVEN;\n    stack.add(inst);\n    let result = NONE;\n    const check = (child) => {\n        if (result !== PROVEN && child?._zod) {\n            const answer = isRecursive(child, stack, resolve);\n            if (answer > result)\n                result = answer;\n        }\n    };\n    // `Reflect.ownKeys` rather than `Object.keys`, so a cycle through a declared symbol key is still seen\n    const shape = (sh, spread) => {\n        let answer = NONE;\n        for (const key of Reflect.ownKeys(sh)) {\n            const desc = Object.getOwnPropertyDescriptor(sh, key);\n            // an object resolves its shape by spread, so a key it does not enumerate is never parsed; `z.properties` reads every own key and so keeps them all\n            if (spread && !desc.enumerable)\n                continue;\n            // resolving runs user code, and a factory mints a fresh subtree per read, so an edge the walk can't follow counts as a cycle\n            const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;\n            if (child > answer)\n                answer = child;\n        }\n        return answer;\n    };\n    const merge = (answer) => {\n        if (answer > result)\n            result = answer;\n    };\n    const def = inst._zod.def;\n    const kind = def.type;\n    switch (kind) {\n        case \"object\": {\n            const raw = util.rawShape(def);\n            // a def with no raw shape answers `shape` from an accessor of its own, and running that can mint a whole fresh subtree\n            merge(raw ? shape(raw, true) : ASSUMED);\n            check(def.catchall);\n            break;\n        }\n        case \"array\":\n            check(def.element);\n            break;\n        case \"tuple\":\n            for (const el of def.items)\n                check(el);\n            check(def.rest);\n            break;\n        case \"record\":\n        case \"map\":\n            check(def.keyType);\n            check(def.valueType);\n            break;\n        case \"set\":\n            check(def.valueType);\n            break;\n        case \"union\":\n            for (const el of def.options)\n                check(el);\n            break;\n        case \"intersection\":\n            check(def.left);\n            check(def.right);\n            break;\n        case \"optional\":\n        case \"nullable\":\n        case \"default\":\n        case \"prefault\":\n        case \"catch\":\n        case \"readonly\":\n        case \"nonoptional\":\n        case \"promise\":\n        case \"success\":\n            check(def.innerType);\n            break;\n        case \"pipe\":\n            check(def.in);\n            check(def.out);\n            break;\n        case \"function\":\n            check(def.input);\n            check(def.output);\n            break;\n        // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly\n        case \"lazy\": {\n            const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : undefined);\n            // walked with resolution off: one hop sees past the deferral, and a lazy that yields only another unresolved lazy is generative, so it stops there\n            merge(inner ? isRecursive(inner, stack, false) : ASSUMED);\n            break;\n        }\n        // a leaf by choice: `parts` are regex fragments, not data positions\n        case \"template_literal\":\n        // leaves\n        case \"string\":\n        case \"number\":\n        case \"int\":\n        case \"boolean\":\n        case \"bigint\":\n        case \"symbol\":\n        case \"undefined\":\n        case \"null\":\n        case \"void\":\n        case \"never\":\n        case \"any\":\n        case \"unknown\":\n        case \"date\":\n        case \"nan\":\n        case \"enum\":\n        case \"literal\":\n        case \"file\":\n        case \"transform\":\n        case \"custom\":\n            break;\n        default: {\n            // a new built-in kind becomes a compile error here\n            kind;\n            // a user-defined kind can still hold children, and only its author knows where, so fall back to scanning the def — skipping accessors, since reading one can run user code\n            for (const key in def) {\n                const desc = Object.getOwnPropertyDescriptor(def, key);\n                if (!desc || desc.get)\n                    continue;\n                const value = desc.value;\n                if (!value || typeof value !== \"object\")\n                    continue;\n                if (value._zod)\n                    check(value);\n                else if (Array.isArray(value))\n                    for (const el of value)\n                        check(el);\n            }\n        }\n    }\n    stack.delete(inst);\n    return settle(inst, result);\n}\n/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */\nfunction settle(inst, answer) {\n    if (answer !== ASSUMED)\n        recursive.set(inst, answer === PROVEN);\n    return answer;\n}\n/**\n * Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.\n * Exported for `z.compile`, which refuses to compile such a schema: cycle\n * breaking is driven from here off state keyed on the parse context, and a\n * generated fast path has no context to key on.\n */\nexport function isRecursiveSchema(inst) {\n    // z.compile never parses, so nothing would ever resolve a lazy for it; it runs once and already treats a throw here as recursive\n    return isRecursive(inst, new Set(), true) !== NONE;\n}\nfunction bucketFor(state, inst) {\n    let bucket = state.buckets.get(inst);\n    if (!bucket) {\n        bucket = new WeakMap();\n        state.buckets.set(inst, bucket);\n    }\n    return bucket;\n}\n// Set immediately before delegating to core and cleared immediately after, so `alloc` registers only for a visit this module is driving.\nlet handoff;\n// Allocated but unfinished entries. `alloc` and the matching pop both happen in the synchronous part of a parse, so they nest even when children are async, and one stack serves every schema.\nconst open = [];\nconst memo = {\n    alloc(_inst, payload, empty) {\n        const bucket = handoff;\n        if (!bucket)\n            return empty;\n        handoff = undefined;\n        const entry = { value: empty, issues: null };\n        bucket.set(payload.value, entry);\n        open.push(entry);\n        return empty;\n    },\n    guard(inst) {\n        var _a;\n        (_a = inst._zod).deferred ?? (_a.deferred = []);\n        inst._zod.deferred.push(() => {\n            const base = inst._zod.parse;\n            const wrapped = (payload, ctx) => {\n                // The value is a placeholder a back-edge is still waiting on, so the cycle closes through this transform. Its output can't exist in time to bind.\n                if (ctx.direction !== \"backward\" && isBackEdge(ctx, payload.value))\n                    throw new $ZodCyclicError();\n                return base(payload, ctx);\n            };\n            inst._zod.parse = wrapped;\n            if (inst._zod.run === base)\n                inst._zod.run = wrapped;\n        });\n    },\n    attach(inst) {\n        var _a;\n        let isRecursiveInst;\n        let rechecked = false;\n        // a recursive schema is re-entered many times per parse and its bucket never changes\n        let lastCtx;\n        let lastBucket;\n        // Wraps `parse` in a deferred so it sees the container's final parse. Core's own deferred copies `parse` into `run` when there are no checks, and it ran first, so `run` is patched to match; with checks, `run` reads `parse` dynamically.\n        (_a = inst._zod).deferred ?? (_a.deferred = []);\n        inst._zod.deferred.push(() => {\n            const base = inst._zod.parse;\n            const wrapped = (payload, ctx) => {\n                if (isRecursiveInst === undefined) {\n                    const walked = isRecursive(inst, new Set(), false);\n                    if (walked === NONE) {\n                        // Nothing here can ever fire, so take it back out.\n                        inst._zod.parse = base;\n                        if (inst._zod.run === wrapped)\n                            inst._zod.run = base;\n                        return base(payload, ctx);\n                    }\n                    // this parse resolves the deferred edges on its own path, so ask once more before latching\n                    if (walked === PROVEN || rechecked)\n                        isRecursiveInst = true;\n                    else\n                        rechecked = true;\n                }\n                const input = payload.value;\n                if (!isRef(input))\n                    return base(payload, ctx);\n                let state = ctx[STATE];\n                if (!state) {\n                    state = { buckets: new WeakMap(), backEdges: undefined };\n                    ctx[STATE] = state;\n                }\n                let bucket;\n                if (lastCtx === ctx) {\n                    bucket = lastBucket;\n                }\n                else {\n                    bucket = bucketFor(state, inst);\n                    lastCtx = ctx;\n                    lastBucket = bucket;\n                }\n                const hit = bucket.get(input);\n                if (hit) {\n                    payload.value = hit.value;\n                    if (hit.issues) {\n                        if (hit.issues.length)\n                            payload.issues.push(...cloneIssues(hit.issues));\n                    }\n                    else {\n                        // Still being parsed: its own checks cover it, so skip them here.\n                        payload.memo = true;\n                        state.backEdges ?? (state.backEdges = new WeakSet());\n                        state.backEdges.add(hit.value);\n                    }\n                    return payload;\n                }\n                handoff = bucket;\n                const depth = open.length;\n                const result = base(payload, ctx);\n                handoff = undefined;\n                // A container that rejected its input outright allocated nothing.\n                const entry = open.length > depth ? open.pop() : undefined;\n                // Both paths written out so the sync one allocates no closure. It runs once per node, and capturing here cost more than everything else combined.\n                if (result instanceof Promise) {\n                    return result.then((r) => {\n                        if (entry)\n                            entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;\n                        return r;\n                    });\n                }\n                if (entry)\n                    entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;\n                return result;\n            };\n            inst._zod.parse = wrapped;\n            if (inst._zod.run === base)\n                inst._zod.run = wrapped;\n        });\n    },\n};\n/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */\nexport function memoizer() {\n    return memo;\n}\n/** Whether this value is a node a back-edge resolved to before it finished. */\nexport function isBackEdge(ctx, value) {\n    const backEdges = ctx[STATE]?.backEdges;\n    return backEdges !== undefined && isRef(value) && backEdges.has(value);\n}\n"],"names":["$ZodCyclicError","STATE","NO_ISSUES","isRef","value","cloneIssues","issues","iss","recursive","NONE","ASSUMED","PROVEN","isRecursive","inst","stack","resolve","cached","result","check","child","answer","shape","sh","spread","key","desc","merge","def","raw","util.rawShape","el","inner","settle","bucketFor","state","bucket","handoff","open","memo","_inst","payload","empty","entry","_a","base","wrapped","ctx","isBackEdge","isRecursiveInst","rechecked","lastCtx","lastBucket","walked","input","hit","depth","r","memoizer","backEdges"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/parse.js

@@ -0,0 +1,113 @@
+import { $ZodAsyncError as f, config as d } from "./core.js";
+import { finalizeIssue as y, captureStackTrace as w } from "./util.js";
+function u(r, n) {
+  return { callee: n?.callee ?? r, Err: n?.Err };
+}
+const b = (r) => {
+  const n = (s, e, t, c) => {
+    const o = t ? { ...t, async: !1 } : { async: !1 }, a = s._zod.run({ value: e, issues: [] }, o);
+    if (a instanceof Promise)
+      throw new f();
+    if (a.issues.length) {
+      const i = new (c?.Err ?? r)(a.issues.map((l) => y(l, o, d())));
+      throw w(i, c?.callee ?? n), i;
+    }
+    return a.value;
+  };
+  return n;
+}, k = (r) => {
+  const n = async (s, e, t, c) => {
+    const o = t ? { ...t, async: !0 } : { async: !0 };
+    let a = s._zod.run({ value: e, issues: [] }, o);
+    if (a instanceof Promise && (a = await a), a.issues.length) {
+      const i = new (c?.Err ?? r)(a.issues.map((l) => y(l, o, d())));
+      throw w(i, c?.callee ?? n), i;
+    }
+    return a.value;
+  };
+  return n;
+}, m = (r) => (n, s, e) => {
+  const t = e ? { ...e, async: !1 } : { async: !1 }, c = n._zod.run({ value: s, issues: [] }, t);
+  if (c instanceof Promise)
+    throw new f();
+  return c.issues.length ? A(r, c.issues, t) : { success: !0, data: c.value };
+};
+function A(r, n, s) {
+  let e;
+  return {
+    success: !1,
+    get error() {
+      return e || (e = new r(n.map((t) => y(t, s, d()))), n = void 0, s = void 0), e;
+    },
+    set error(t) {
+      e = t, n = void 0, s = void 0;
+    }
+  };
+}
+const E = (r) => async (n, s, e) => {
+  const t = e ? { ...e, async: !0 } : { async: !0 };
+  let c = n._zod.run({ value: s, issues: [] }, t);
+  return c instanceof Promise && (c = await c), c.issues.length ? A(r, c.issues, t) : { success: !0, data: c.value };
+}, p = /* @__PURE__ */ Symbol.for("zod.compile.invalid"), z = /* @__PURE__ */ Symbol.for("zod.compile.fallback"), h = ((r, n, s) => {
+  const e = r._zod.bag.validator;
+  if (e !== void 0) {
+    if (e(n) !== p)
+      return !0;
+    if (e.definite === !0 && s === void 0)
+      return !1;
+  }
+  return P(r, n, s);
+});
+function P(r, n, s) {
+  const e = s ? { ...s, async: !1, abortEarly: !0 } : { async: !1, abortEarly: !0 }, t = r._zod.bag.fallbackRun;
+  let c;
+  if (t ? (e[z] = !0, c = t({ value: n, issues: [] }, e)) : c = r._zod.run({ value: n, issues: [] }, e), c instanceof Promise)
+    throw new f();
+  return c.issues.length === 0;
+}
+const v = async (r, n, s) => {
+  const e = s ? { ...s, async: !0, abortEarly: !0 } : { async: !0, abortEarly: !0 };
+  let t = r._zod.run({ value: n, issues: [] }, e);
+  return t instanceof Promise && (t = await t), t.issues.length === 0;
+}, I = (r) => {
+  const n = b(r), s = (e, t, c, o) => {
+    const a = c ? { ...c, direction: "backward" } : { direction: "backward" };
+    return n(e, t, a, u(s, o));
+  };
+  return s;
+}, L = (r) => {
+  const n = b(r), s = (e, t, c, o) => n(e, t, c, u(s, o));
+  return s;
+}, C = (r) => {
+  const n = k(r), s = async (e, t, c, o) => {
+    const a = c ? { ...c, direction: "backward" } : { direction: "backward" };
+    return await n(e, t, a, u(s, o));
+  };
+  return s;
+}, D = (r) => {
+  const n = k(r), s = async (e, t, c, o) => await n(e, t, c, u(s, o));
+  return s;
+}, S = (r) => (n, s, e) => {
+  const t = e ? { ...e, direction: "backward" } : { direction: "backward" };
+  return m(r)(n, s, t);
+}, F = (r) => (n, s, e) => m(r)(n, s, e), M = (r) => async (n, s, e) => {
+  const t = e ? { ...e, direction: "backward" } : { direction: "backward" };
+  return E(r)(n, s, t);
+}, O = (r) => async (n, s, e) => E(r)(n, s, e);
+export {
+  L as _decode,
+  D as _decodeAsync,
+  I as _encode,
+  C as _encodeAsync,
+  b as _parse,
+  k as _parseAsync,
+  F as _safeDecode,
+  O as _safeDecodeAsync,
+  S as _safeEncode,
+  M as _safeEncodeAsync,
+  m as _safeParse,
+  E as _safeParseAsync,
+  h as validate,
+  v as validateAsync
+};
+//# sourceMappingURL=parse.js.map

package/dist/node_modules/zod/v4/core/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sources":["../../../../../../../node_modules/zod/v4/core/parse.js"],"sourcesContent":["import * as core from \"./core.js\";\nimport * as errors from \"./errors.js\";\nimport * as util from \"./util.js\";\n// Always both keys, so the `_params` read site in `_parse` sees one object shape rather than two.\nfunction finalizeParams(callee, params) {\n    return { callee: params?.callee ?? callee, Err: params?.Err };\n}\nexport const _parse = (_Err) => {\n    const fn = (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n        const result = schema._zod.run({ value, issues: [] }, ctx);\n        if (result instanceof Promise) {\n            throw new core.$ZodAsyncError();\n        }\n        if (result.issues.length) {\n            const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n            util.captureStackTrace(e, _params?.callee ?? fn);\n            throw e;\n        }\n        return result.value;\n    };\n    return fn;\n};\nexport const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);\nexport const _parseAsync = (_Err) => {\n    const fn = async (schema, value, _ctx, params) => {\n        const ctx = _ctx ? { ..._ctx, async: true } : { async: true };\n        let result = schema._zod.run({ value, issues: [] }, ctx);\n        if (result instanceof Promise)\n            result = await result;\n        if (result.issues.length) {\n            const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n            util.captureStackTrace(e, params?.callee ?? fn);\n            throw e;\n        }\n        return result.value;\n    };\n    return fn;\n};\nexport const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);\nexport const _safeParse = (_Err) => (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n    const result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise) {\n        throw new core.$ZodAsyncError();\n    }\n    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };\n};\nexport const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);\n// the error is built on the first read of `error`: finalizing the issues and constructing the instance is most of a failing parse, and a caller that only branches on `success` never pays it. a getter in the literal keeps this small; the alternative, one shared accessor descriptor plus a hidden state slot, reads ~15% faster but costs ~75 B gzipped in every bundle\nfunction failure(Err, issues, ctx) {\n    let error;\n    return {\n        success: false,\n        get error() {\n            if (!error) {\n                error = new Err(issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n                // finalizeIssue drops `input`, so the built error holds nothing; keeping the raw issues past this point pins the parsed value for the life of the result\n                issues = undefined;\n                ctx = undefined;\n            }\n            return error;\n        },\n        set error(e) {\n            error = e;\n            // a replacement makes the getter's branch unreachable, so the captures have to go here too\n            issues = undefined;\n            ctx = undefined;\n        },\n    };\n}\nexport const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };\n    let result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise)\n        result = await result;\n    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };\n};\nexport const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);\n// registry mirrors of the compiler's sentinels, so this module never imports the compiler\nconst COMPILE_INVALID = /* @__PURE__ */ Symbol.for(\"zod.compile.invalid\");\nconst COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for(\"zod.compile.fallback\");\n// Deliberately tiny, because v8 will not inline a body carrying the fallback's object literals and throw. Everything that is not the compiled happy path lives in validateFallback, and that split is worth ~35% on a compiled schema.\nexport const validate = ((schema, value, _ctx) => {\n    const validator = schema._zod.bag.validator;\n    if (validator !== undefined) {\n        if (validator(value) !== COMPILE_INVALID)\n            return true;\n        // a definite sentinel means the runtime would reject, so skip the re-parse; a ctx can still change the answer\n        if (validator.definite === true && _ctx === undefined)\n            return false;\n    }\n    return validateFallback(schema, value, _ctx);\n});\nfunction validateFallback(schema, value, _ctx) {\n    const ctx = _ctx\n        ? { ..._ctx, async: false, abortEarly: true }\n        : { async: false, abortEarly: true };\n    const fallbackRun = schema._zod.bag.fallbackRun;\n    let result;\n    if (fallbackRun) {\n        // skip nested fast paths on the fallback, so user callbacks keep the at-most-twice bound\n        ctx[COMPILE_FALLBACK] = true;\n        result = fallbackRun({ value, issues: [] }, ctx);\n    }\n    else {\n        result = schema._zod.run({ value, issues: [] }, ctx);\n    }\n    if (result instanceof Promise) {\n        throw new core.$ZodAsyncError();\n    }\n    return result.issues.length === 0;\n}\n// no fast path: the compiler keeps async parses on the runtime, because a promise-returning callback that is not declared async compiles to a throw\nexport const validateAsync = async (schema, value, _ctx) => {\n    const ctx = _ctx\n        ? { ..._ctx, async: true, abortEarly: true }\n        : { async: true, abortEarly: true };\n    let result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise)\n        result = await result;\n    return result.issues.length === 0;\n};\nexport const _encode = (_Err) => {\n    const parse = _parse(_Err);\n    const fn = (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n        return parse(schema, value, ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);\nexport const _decode = (_Err) => {\n    const parse = _parse(_Err);\n    const fn = (schema, value, _ctx, _params) => {\n        return parse(schema, value, _ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);\nexport const _encodeAsync = (_Err) => {\n    const parseAsync = _parseAsync(_Err);\n    const fn = async (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n        return (await parseAsync(schema, value, ctx, finalizeParams(fn, _params)));\n    };\n    return fn;\n};\nexport const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);\nexport const _decodeAsync = (_Err) => {\n    const parseAsync = _parseAsync(_Err);\n    const fn = async (schema, value, _ctx, _params) => {\n        return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);\nexport const _safeEncode = (_Err) => (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n    return _safeParse(_Err)(schema, value, ctx);\n};\nexport const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);\nexport const _safeDecode = (_Err) => (schema, value, _ctx) => {\n    return _safeParse(_Err)(schema, value, _ctx);\n};\nexport const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);\nexport const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n    return _safeParseAsync(_Err)(schema, value, ctx);\n};\nexport const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);\nexport const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n    return _safeParseAsync(_Err)(schema, value, _ctx);\n};\nexport const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);\n"],"names":["finalizeParams","callee","params","_parse","_Err","fn","schema","value","_ctx","_params","ctx","result","core.$ZodAsyncError","e","iss","util.finalizeIssue","core.config","util.captureStackTrace","_parseAsync","_safeParse","failure","Err","issues","error","_safeParseAsync","COMPILE_INVALID","COMPILE_FALLBACK","validate","validator","validateFallback","fallbackRun","validateAsync","_encode","parse","_decode","_encodeAsync","parseAsync","_decodeAsync","_safeEncode","_safeDecode","_safeEncodeAsync","_safeDecodeAsync"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/regexes.js

@@ -0,0 +1,59 @@
+const d = /^[cC][0-9a-z]{6,}$/, i = /^[0-9a-z]+$/, s = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/, F = /^[0-9a-vA-V]{20}$/, $ = /^[A-Za-z0-9]{27}$/, r = /^[a-zA-Z0-9_-]{21}$/;
+function u(f) {
+  return new RegExp(`^[a-zA-Z0-9_-]{${f}}$`);
+}
+const p = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/, z = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/, Z = (f) => f ? new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${f}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`) : /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/, m = /^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/, A = "^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$";
+function x() {
+  return new RegExp(A, "u");
+}
+const _ = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, l = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/, h = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/, E = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, g = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/, R = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/, b = /^https?$/, w = /^\+[1-9]\d{6,14}$/, o = "(?:(?:\\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])))";
+function c(f) {
+  return new RegExp(`^${f}$`);
+}
+const S = /* @__PURE__ */ c(o);
+function t(f) {
+  const n = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+  return typeof f.precision == "number" ? f.precision === -1 ? `${n}` : f.precision === 0 ? `${n}:[0-5]\\d` : `${n}:[0-5]\\d\\.\\d{${f.precision}}` : f.seconds ? `${n}:[0-5]\\d(?:\\.\\d+)?` : `${n}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function j(f) {
+  return new RegExp(`^${t(f)}$`);
+}
+function v(f) {
+  const n = ["Z"];
+  f.offset && n.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
+  const a = `${t({ precision: f.precision, seconds: !0 })}(?:${n.join("|")})`, e = f.local ? `${a}|${t({ precision: f.precision })}` : a;
+  return new RegExp(`^${o}T(?:${e})$`);
+}
+const P = /^[\s\S]{0,}$/, T = /^-?\d+$/, M = /^-?\d+(?:\.\d+)?$/, k = /^(?:true|false)$/i, y = /^[^A-Z]*$/, B = /^[^a-z]*$/;
+export {
+  P as anyString,
+  g as base64,
+  R as base64url,
+  k as boolean,
+  h as cidrv4,
+  E as cidrv6,
+  d as cuid,
+  i as cuid2,
+  S as date,
+  v as datetime,
+  p as duration,
+  w as e164,
+  m as email,
+  x as emoji,
+  z as guid,
+  b as httpProtocol,
+  T as integer,
+  _ as ipv4,
+  l as ipv6,
+  $ as ksuid,
+  y as lowercase,
+  r as nanoid,
+  u as nanoidOfLength,
+  M as number,
+  j as time,
+  s as ulid,
+  B as uppercase,
+  Z as uuid,
+  F as xid
+};
+//# sourceMappingURL=regexes.js.map

package/dist/node_modules/zod/v4/core/regexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexes.js","sources":["../../../../../../../node_modules/zod/v4/core/regexes.js"],"sourcesContent":["import * as util from \"./util.js\";\n/**\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link cuid2} instead.\n * See https://github.com/paralleldrive/cuid.\n */\nexport const cuid = /^[cC][0-9a-z]{6,}$/;\nexport const cuid2 = /^[0-9a-z]+$/;\nexport const ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;\nexport const xid = /^[0-9a-vA-V]{20}$/;\nexport const ksuid = /^[A-Za-z0-9]{27}$/;\nexport const nanoid = /^[a-zA-Z0-9_-]{21}$/;\nexport function nanoidOfLength(length) {\n    return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);\n}\n/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */\nexport const duration = /^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$/;\n/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */\nexport const extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\n/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */\nexport const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n/** Returns a regex for validating an RFC 9562/4122 UUID.\n *\n * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */\nexport const uuid = (version) => {\n    if (!version)\n        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;\n    return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n};\nexport const uuid4 = /*@__PURE__*/ uuid(4);\nexport const uuid6 = /*@__PURE__*/ uuid(6);\nexport const uuid7 = /*@__PURE__*/ uuid(7);\n/** Practical email validation */\nexport const email = /^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/;\n/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */\nexport const html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n/** The classic emailregex.com regex for RFC 5322-compliant emails */\nexport const rfc5322Email = /^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/;\n/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */\nexport const unicodeEmail = /^[^\\s@\"]{1,64}@[^\\s@]{1,255}$/u;\nexport const idnEmail = unicodeEmail;\nexport const browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression\n// Single character class, not an alternation: the two properties overlap (U+1F9B0-U+1F9B3), so `(A|B)+` backtracks exponentially on a failed match. The leading lookahead then demands one anchor — a pictograph, a regional indicator, or the enclosing keycap — because `\\p{Emoji_Component}` on its own covers ASCII digits, `#`, `*`, ZWJ, variation selectors and skin tone modifiers, none of which is an emoji without a base.\nconst _emoji = `^(?=[\\\\s\\\\S]*[\\\\p{Extended_Pictographic}\\\\p{Regional_Indicator}\\\\u20E3])[\\\\p{Extended_Pictographic}\\\\p{Emoji_Component}]+$`;\nexport function emoji() {\n    return new RegExp(_emoji, \"u\");\n}\nexport const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nexport const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;\nexport const mac = (delimiter) => {\n    const escapedDelim = util.escapeRegex(delimiter ?? \":\");\n    return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);\n};\nexport const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/([0-9]|[1-2][0-9]|3[0-2])$/;\nexport const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\n// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript\nexport const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;\nexport const base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;\n// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address\n// export const hostname: RegExp = /^([a-zA-Z0-9-]+\\.)*[a-zA-Z0-9-]+$/;\nexport const hostname = /^(?=.{1,253}\\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\\.?$/;\nexport const domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}$/;\nexport const httpProtocol = /^https?$/;\n// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces) E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15\nexport const e164 = /^\\+[1-9]\\d{6,14}$/;\n// Credit card shape: 12–19 digits, optionally separated by single spaces or single hyphens. ISO/IEC 7812 caps the PAN at 19 digits; 12 is the shortest issued length (Maestro).\nexport const creditCard = /^\\d(?:[ -]?\\d){11,18}$/;\n// ISO 4217 alpha codes from the SIX list, regenerated by scripts/update-iso-4217.ts\nexport const currencyCode = /^(?:AED|AFN|ALL|AMD|AOA|ARS|AUD|AWG|AZN|BAM|BBD|BDT|BHD|BIF|BMD|BND|BOB|BOV|BRL|BSD|BTN|BWP|BYN|BZD|CAD|CDF|CHE|CHF|CHW|CLF|CLP|CNY|COP|COU|CRC|CUP|CVE|CZK|DJF|DKK|DOP|DZD|EGP|ERN|ETB|EUR|FJD|FKP|GBP|GEL|GHS|GIP|GMD|GNF|GTQ|GYD|HKD|HNL|HTG|HUF|IDR|ILS|INR|IQD|IRR|ISK|JMD|JOD|JPY|KES|KGS|KHR|KMF|KPW|KRW|KWD|KYD|KZT|LAK|LBP|LKR|LRD|LSL|LYD|MAD|MDL|MGA|MKD|MMK|MNT|MOP|MRU|MUR|MVR|MWK|MXN|MXV|MYR|MZN|NAD|NGN|NIO|NOK|NPR|NZD|OMR|PAB|PEN|PGK|PHP|PKR|PLN|PYG|QAR|RON|RSD|RUB|RWF|SAR|SBD|SCR|SDG|SEK|SGD|SHP|SLE|SOS|SRD|SSP|STN|SVC|SYP|SZL|THB|TJS|TMT|TND|TOP|TRY|TTD|TWD|TZS|UAH|UGX|USD|USN|UYI|UYU|UYW|UZS|VED|VES|VND|VUV|WST|XAD|XAF|XAG|XAU|XBA|XBB|XBC|XBD|XCD|XCG|XDR|XOF|XPD|XPF|XPT|XSU|XTS|XUA|XXX|YER|ZAR|ZMW|ZWG)$/;\n// iban electronic format: 2-letter country, check digits 02-98 (the only values `98 - remainder` can produce), 11-30 bban characters\nexport const iban = /^[A-Z]{2}(?!00|01|99)\\d{2}[A-Z0-9]{11,30}$/;\nconst dateSource = `(?:(?:\\\\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])))`;\n/** Anchors a pattern source. The interpolation lives here rather than at the call site because\n * esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it\n * will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */\nfunction anchor(source) {\n    return new RegExp(`^${source}$`);\n}\nexport const date = /*@__PURE__*/ anchor(dateSource);\nfunction timeSource(args) {\n    const hhmm = `(?:[01]\\\\d|2[0-3]):[0-5]\\\\d`;\n    const regex = typeof args.precision === \"number\"\n        ? args.precision === -1\n            ? `${hhmm}`\n            : args.precision === 0\n                ? `${hhmm}:[0-5]\\\\d`\n                : `${hhmm}:[0-5]\\\\d\\\\.\\\\d{${args.precision}}`\n        : args.seconds\n            ? `${hhmm}:[0-5]\\\\d(?:\\\\.\\\\d+)?`\n            : `${hhmm}(?::[0-5]\\\\d(?:\\\\.\\\\d+)?)?`;\n    return regex;\n}\nexport function time(args) {\n    return new RegExp(`^${timeSource(args)}$`);\n}\n// Adapted from https://stackoverflow.com/a/3143231\nexport function datetime(args) {\n    const opts = [\"Z\"];\n    // if (args.offset) opts.push(`([+-]\\\\d{2}:\\\\d{2})`);\n    if (args.offset)\n        opts.push(`([+-](?:[01]\\\\d|2[0-3]):[0-5]\\\\d)`);\n    // RFC 3339 mandates seconds wherever the time carries a `Z` or an offset, so only the unqualified form `local` adds may omit them\n    const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join(\"|\")})`;\n    const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;\n    return new RegExp(`^${dateSource}T(?:${timeRegex})$`);\n}\n// the unbounded form of `string()` as a literal, so every plain string shares one instance instead of building its own\nexport const anyString = /^[\\s\\S]{0,}$/;\nexport const string = (params) => {\n    const regex = params ? `[\\\\s\\\\S]{${params?.minimum ?? 0},${params?.maximum ?? \"\"}}` : `[\\\\s\\\\S]*`;\n    return new RegExp(`^${regex}$`);\n};\nexport const bigint = /^-?\\d+n?$/;\nexport const integer = /^-?\\d+$/;\nexport const number = /^-?\\d+(?:\\.\\d+)?$/;\nexport const boolean = /^(?:true|false)$/i;\nconst _null = /^null$/i;\nexport { _null as null };\nconst _undefined = /^undefined$/i;\nexport { _undefined as undefined };\n// regex for string with no uppercase letters\nexport const lowercase = /^[^A-Z]*$/;\n// regex for string with no lowercase letters\nexport const uppercase = /^[^a-z]*$/;\n// regex for hexadecimal strings (any length)\nexport const hex = /^[0-9a-fA-F]*$/;\n// Hash regexes for different algorithms and encodings\n// Helper function to create base64 regex with exact length and padding\nfunction fixedBase64(bodyLength, padding) {\n    return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);\n}\n// Helper function to create base64url regex with exact length (no padding)\nfunction fixedBase64url(length) {\n    return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n}\n// MD5 (16 bytes): base64 = 24 chars total (22 + \"==\")\nexport const md5_hex = /^[0-9a-fA-F]{32}$/;\nexport const md5_base64 = /*@__PURE__*/ fixedBase64(22, \"==\");\nexport const md5_base64url = /*@__PURE__*/ fixedBase64url(22);\n// SHA1 (20 bytes): base64 = 28 chars total (27 + \"=\")\nexport const sha1_hex = /^[0-9a-fA-F]{40}$/;\nexport const sha1_base64 = /*@__PURE__*/ fixedBase64(27, \"=\");\nexport const sha1_base64url = /*@__PURE__*/ fixedBase64url(27);\n// SHA256 (32 bytes): base64 = 44 chars total (43 + \"=\")\nexport const sha256_hex = /^[0-9a-fA-F]{64}$/;\nexport const sha256_base64 = /*@__PURE__*/ fixedBase64(43, \"=\");\nexport const sha256_base64url = /*@__PURE__*/ fixedBase64url(43);\n// SHA384 (48 bytes): base64 = 64 chars total (no padding)\nexport const sha384_hex = /^[0-9a-fA-F]{96}$/;\nexport const sha384_base64 = /*@__PURE__*/ fixedBase64(64, \"\");\nexport const sha384_base64url = /*@__PURE__*/ fixedBase64url(64);\n// SHA512 (64 bytes): base64 = 88 chars total (86 + \"==\")\nexport const sha512_hex = /^[0-9a-fA-F]{128}$/;\nexport const sha512_base64 = /*@__PURE__*/ fixedBase64(86, \"==\");\nexport const sha512_base64url = /*@__PURE__*/ fixedBase64url(86);\n"],"names":["cuid","cuid2","ulid","xid","ksuid","nanoid","nanoidOfLength","length","duration","guid","uuid","version","email","_emoji","emoji","ipv4","ipv6","cidrv4","cidrv6","base64","base64url","httpProtocol","e164","dateSource","anchor","source","date","timeSource","args","hhmm","time","datetime","opts","qualified","timeRegex","anyString","integer","number","boolean","lowercase","uppercase"],"mappings":"AAMY,MAACA,IAAO,sBACPC,IAAQ,eACRC,IAAO,8CACPC,IAAM,qBACNC,IAAQ,qBACRC,IAAS;AACf,SAASC,EAAeC,GAAQ;AACnC,SAAO,IAAI,OAAO,kBAAkBA,CAAM,IAAI;AAClD;AAEY,MAACC,IAAW,iGAIXC,IAAO,mFAIPC,IAAO,CAACC,MACZA,IAEE,IAAI,OAAO,mCAAmCA,CAAO,yDAAyD,IAD1G,0KAOFC,IAAQ,0GAWfC,IAAS;AACR,SAASC,IAAQ;AACpB,SAAO,IAAI,OAAOD,GAAQ,GAAG;AACjC;AACY,MAACE,IAAO,uHACPC,IAAO,gYAKPC,IAAS,4IACTC,IAAS,kaAETC,IAAS,+EACTC,IAAY,kDAKZC,IAAe,YAEfC,IAAO,qBAOdC,IAAa;AAInB,SAASC,EAAOC,GAAQ;AACpB,SAAO,IAAI,OAAO,IAAIA,CAAM,GAAG;AACnC;AACY,MAACC,IAAqB,gBAAAF,EAAOD,CAAU;AACnD,SAASI,EAAWC,GAAM;AACtB,QAAMC,IAAO;AAUb,SATc,OAAOD,EAAK,aAAc,WAClCA,EAAK,cAAc,KACf,GAAGC,CAAI,KACPD,EAAK,cAAc,IACf,GAAGC,CAAI,cACP,GAAGA,CAAI,mBAAmBD,EAAK,SAAS,MAChDA,EAAK,UACD,GAAGC,CAAI,0BACP,GAAGA,CAAI;AAErB;AACO,SAASC,EAAKF,GAAM;AACvB,SAAO,IAAI,OAAO,IAAID,EAAWC,CAAI,CAAC,GAAG;AAC7C;AAEO,SAASG,EAASH,GAAM;AAC3B,QAAMI,IAAO,CAAC,GAAG;AAEjB,EAAIJ,EAAK,UACLI,EAAK,KAAK,mCAAmC;AAEjD,QAAMC,IAAY,GAAGN,EAAW,EAAE,WAAWC,EAAK,WAAW,SAAS,GAAI,CAAE,CAAC,MAAMI,EAAK,KAAK,GAAG,CAAC,KAC3FE,IAAYN,EAAK,QAAQ,GAAGK,CAAS,IAAIN,EAAW,EAAE,WAAWC,EAAK,UAAS,CAAE,CAAC,KAAKK;AAC7F,SAAO,IAAI,OAAO,IAAIV,CAAU,OAAOW,CAAS,IAAI;AACxD;AAEY,MAACC,IAAY,gBAMZC,IAAU,WACVC,IAAS,qBACTC,IAAU,qBAMVC,IAAY,aAEZC,IAAY;","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/registries.js

@@ -0,0 +1,41 @@
+var a;
+class r {
+  constructor() {
+    this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(t, ...e) {
+    const i = e[0];
+    return this._map.set(t, i), i && typeof i == "object" && "id" in i && this._idmap.set(i.id, t), this;
+  }
+  clear() {
+    return this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map(), this;
+  }
+  remove(t) {
+    const e = this._map.get(t);
+    return e && typeof e == "object" && "id" in e && this._idmap.delete(e.id), this._map.delete(t), this;
+  }
+  get(t) {
+    const e = t._zod.parent;
+    if (e) {
+      const i = { ...this.get(e) ?? {} };
+      delete i.id;
+      const s = { ...i, ...this._map.get(t) };
+      return Object.keys(s).length ? s : void 0;
+    }
+    return this._map.get(t);
+  }
+  has(t) {
+    return this._map.has(t);
+  }
+}
+function n() {
+  return new r();
+}
+(a = globalThis).__zod_globalRegistry ?? (a.__zod_globalRegistry = n());
+const _ = globalThis.__zod_globalRegistry;
+export {
+  r as $ZodRegistry,
+  _ as globalRegistry,
+  n as registry
+};
+//# sourceMappingURL=registries.js.map

package/dist/node_modules/zod/v4/core/registries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registries.js","sources":["../../../../../../../node_modules/zod/v4/core/registries.js"],"sourcesContent":["var _a;\nexport const $output = /*@__PURE__*/ Symbol(\"ZodOutput\");\nexport const $input = /*@__PURE__*/ Symbol(\"ZodInput\");\nexport class $ZodRegistry {\n    constructor() {\n        this._map = new WeakMap();\n        this._idmap = new Map();\n    }\n    add(schema, ..._meta) {\n        const meta = _meta[0];\n        this._map.set(schema, meta);\n        if (meta && typeof meta === \"object\" && \"id\" in meta) {\n            this._idmap.set(meta.id, schema);\n        }\n        return this;\n    }\n    clear() {\n        this._map = new WeakMap();\n        this._idmap = new Map();\n        return this;\n    }\n    remove(schema) {\n        const meta = this._map.get(schema);\n        if (meta && typeof meta === \"object\" && \"id\" in meta) {\n            this._idmap.delete(meta.id);\n        }\n        this._map.delete(schema);\n        return this;\n    }\n    get(schema) {\n        // return this._map.get(schema) as any;\n        // inherit metadata\n        const p = schema._zod.parent;\n        if (p) {\n            const pm = { ...(this.get(p) ?? {}) };\n            delete pm.id; // do not inherit id\n            const f = { ...pm, ...this._map.get(schema) };\n            return Object.keys(f).length ? f : undefined;\n        }\n        return this._map.get(schema);\n    }\n    has(schema) {\n        return this._map.has(schema);\n    }\n}\n// registries\nexport function registry() {\n    return new $ZodRegistry();\n}\n(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());\nexport const globalRegistry = globalThis.__zod_globalRegistry;\n"],"names":["_a","$ZodRegistry","schema","_meta","meta","p","pm","f","registry","globalRegistry"],"mappings":"AAAA,IAAIA;AAGG,MAAMC,EAAa;AAAA,EACtB,cAAc;AACV,SAAK,OAAO,oBAAI,QAAO,GACvB,KAAK,SAAS,oBAAI,IAAG;AAAA,EACzB;AAAA,EACA,IAAIC,MAAWC,GAAO;AAClB,UAAMC,IAAOD,EAAM,CAAC;AACpB,gBAAK,KAAK,IAAID,GAAQE,CAAI,GACtBA,KAAQ,OAAOA,KAAS,YAAY,QAAQA,KAC5C,KAAK,OAAO,IAAIA,EAAK,IAAIF,CAAM,GAE5B;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,gBAAK,OAAO,oBAAI,QAAO,GACvB,KAAK,SAAS,oBAAI,IAAG,GACd;AAAA,EACX;AAAA,EACA,OAAOA,GAAQ;AACX,UAAME,IAAO,KAAK,KAAK,IAAIF,CAAM;AACjC,WAAIE,KAAQ,OAAOA,KAAS,YAAY,QAAQA,KAC5C,KAAK,OAAO,OAAOA,EAAK,EAAE,GAE9B,KAAK,KAAK,OAAOF,CAAM,GAChB;AAAA,EACX;AAAA,EACA,IAAIA,GAAQ;AAGR,UAAMG,IAAIH,EAAO,KAAK;AACtB,QAAIG,GAAG;AACH,YAAMC,IAAK,EAAE,GAAI,KAAK,IAAID,CAAC,KAAK,CAAA,EAAG;AACnC,aAAOC,EAAG;AACV,YAAMC,IAAI,EAAE,GAAGD,GAAI,GAAG,KAAK,KAAK,IAAIJ,CAAM,EAAC;AAC3C,aAAO,OAAO,KAAKK,CAAC,EAAE,SAASA,IAAI;AAAA,IACvC;AACA,WAAO,KAAK,KAAK,IAAIL,CAAM;AAAA,EAC/B;AAAA,EACA,IAAIA,GAAQ;AACR,WAAO,KAAK,KAAK,IAAIA,CAAM;AAAA,EAC/B;AACJ;AAEO,SAASM,IAAW;AACvB,SAAO,IAAIP,EAAY;AAC3B;AAAA,CACCD,IAAK,YAAY,yBAAyBA,EAAG,uBAAuBQ,EAAQ;AACjE,MAACC,IAAiB,WAAW;","x_google_ignoreList":[0]}