@cardelli/ambit 0.1.0

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.d.ts

@@ -0,0 +1,109 @@
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://toml.io | TOML} encoded data.
+ *
+ * Be sure to read the supported types as not every spec is supported at the
+ * moment and the handling in TypeScript side is a bit different.
+ *
+ * ## Supported types and handling
+ *
+ * - [x] [Keys](https://toml.io/en/latest#keys)
+ * - [ ] [String](https://toml.io/en/latest#string)
+ * - [x] [Multiline String](https://toml.io/en/latest#string)
+ * - [x] [Literal String](https://toml.io/en/latest#string)
+ * - [ ] [Integer](https://toml.io/en/latest#integer)
+ * - [x] [Float](https://toml.io/en/latest#float)
+ * - [x] [Boolean](https://toml.io/en/latest#boolean)
+ * - [x] [Offset Date-time](https://toml.io/en/latest#offset-date-time)
+ * - [x] [Local Date-time](https://toml.io/en/latest#local-date-time)
+ * - [x] [Local Date](https://toml.io/en/latest#local-date)
+ * - [ ] [Local Time](https://toml.io/en/latest#local-time)
+ * - [x] [Table](https://toml.io/en/latest#table)
+ * - [x] [Inline Table](https://toml.io/en/latest#inline-table)
+ * - [ ] [Array of Tables](https://toml.io/en/latest#array-of-tables)
+ *
+ * _Supported with warnings see [Warning](#Warning)._
+ *
+ * ### Warning
+ *
+ * #### String
+ *
+ * Due to the spec, there is no flag to detect regex properly in a TOML
+ * declaration. So the regex is stored as string.
+ *
+ * #### Integer
+ *
+ * For **Binary** / **Octal** / **Hexadecimal** numbers, they are stored as string
+ * to be not interpreted as Decimal.
+ *
+ * #### Local Time
+ *
+ * Because local time does not exist in JavaScript, the local time is stored as a
+ * string.
+ *
+ * #### Array of Tables
+ *
+ * At the moment only simple declarations like below are supported:
+ *
+ * ```toml
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * ```
+ *
+ * will output:
+ *
+ * ```json
+ * {
+ *   "bin": [
+ *     { "name": "deno", "path": "cli/main.rs" },
+ *     { "name": "deno_core", "path": "src/foo.rs" }
+ *   ],
+ *   "nib": [{ "name": "node", "path": "not_found" }]
+ * }
+ * ```
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/toml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   bin: [
+ *     { name: "deno", path: "cli/main.rs" },
+ *     { name: "deno_core", path: "src/foo.rs" },
+ *   ],
+ *   nib: [{ name: "node", path: "not_found" }],
+ * };
+ *
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * `);
+ *
+ * const tomlObject = parse(tomlString);
+ * assertEquals(tomlObject, obj);
+ * ```
+ *
+ * @module
+ */
+export * from "./stringify.js";
+export * from "./parse.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.js

@@ -0,0 +1,110 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://toml.io | TOML} encoded data.
+ *
+ * Be sure to read the supported types as not every spec is supported at the
+ * moment and the handling in TypeScript side is a bit different.
+ *
+ * ## Supported types and handling
+ *
+ * - [x] [Keys](https://toml.io/en/latest#keys)
+ * - [ ] [String](https://toml.io/en/latest#string)
+ * - [x] [Multiline String](https://toml.io/en/latest#string)
+ * - [x] [Literal String](https://toml.io/en/latest#string)
+ * - [ ] [Integer](https://toml.io/en/latest#integer)
+ * - [x] [Float](https://toml.io/en/latest#float)
+ * - [x] [Boolean](https://toml.io/en/latest#boolean)
+ * - [x] [Offset Date-time](https://toml.io/en/latest#offset-date-time)
+ * - [x] [Local Date-time](https://toml.io/en/latest#local-date-time)
+ * - [x] [Local Date](https://toml.io/en/latest#local-date)
+ * - [ ] [Local Time](https://toml.io/en/latest#local-time)
+ * - [x] [Table](https://toml.io/en/latest#table)
+ * - [x] [Inline Table](https://toml.io/en/latest#inline-table)
+ * - [ ] [Array of Tables](https://toml.io/en/latest#array-of-tables)
+ *
+ * _Supported with warnings see [Warning](#Warning)._
+ *
+ * ### Warning
+ *
+ * #### String
+ *
+ * Due to the spec, there is no flag to detect regex properly in a TOML
+ * declaration. So the regex is stored as string.
+ *
+ * #### Integer
+ *
+ * For **Binary** / **Octal** / **Hexadecimal** numbers, they are stored as string
+ * to be not interpreted as Decimal.
+ *
+ * #### Local Time
+ *
+ * Because local time does not exist in JavaScript, the local time is stored as a
+ * string.
+ *
+ * #### Array of Tables
+ *
+ * At the moment only simple declarations like below are supported:
+ *
+ * ```toml
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * ```
+ *
+ * will output:
+ *
+ * ```json
+ * {
+ *   "bin": [
+ *     { "name": "deno", "path": "cli/main.rs" },
+ *     { "name": "deno_core", "path": "src/foo.rs" }
+ *   ],
+ *   "nib": [{ "name": "node", "path": "not_found" }]
+ * }
+ * ```
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/toml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   bin: [
+ *     { name: "deno", path: "cli/main.rs" },
+ *     { name: "deno_core", path: "src/foo.rs" },
+ *   ],
+ *   nib: [{ name: "node", path: "not_found" }],
+ * };
+ *
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * `);
+ *
+ * const tomlObject = parse(tomlString);
+ * assertEquals(tomlObject, obj);
+ * ```
+ *
+ * @module
+ */
+export * from "./stringify.js";
+export * from "./parse.js";

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Parses a {@link https://toml.io | TOML} string into an object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/toml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tomlString = `title = "TOML Example"
+ * [owner]
+ * name = "Alice"
+ * bio = "Alice is a programmer."`;
+ *
+ * const obj = parse(tomlString);
+ * assertEquals(obj, { title: "TOML Example", owner: { name: "Alice", bio: "Alice is a programmer." } });
+ * ```
+ * @param tomlString TOML string to be parsed.
+ * @returns The parsed JS object.
+ */
+export declare function parse(tomlString: string): Record<string, unknown>;
+//# sourceMappingURL=parse.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/parse.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjE"}

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.js

@@ -0,0 +1,25 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parserFactory, toml } from "./_parser.js";
+/**
+ * Parses a {@link https://toml.io | TOML} string into an object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/toml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tomlString = `title = "TOML Example"
+ * [owner]
+ * name = "Alice"
+ * bio = "Alice is a programmer."`;
+ *
+ * const obj = parse(tomlString);
+ * assertEquals(obj, { title: "TOML Example", owner: { name: "Alice", bio: "Alice is a programmer." } });
+ * ```
+ * @param tomlString TOML string to be parsed.
+ * @returns The parsed JS object.
+ */
+export function parse(tomlString) {
+    return parserFactory(toml)(tomlString);
+}

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for {@linkcode stringify}.
+ */
+export interface StringifyOptions {
+    /**
+     * Define if the keys should be aligned or not.
+     *
+     * @default {false}
+     */
+    keyAlignment?: boolean;
+}
+/**
+ * Converts an object to a {@link https://toml.io | TOML} string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/toml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   title: "TOML Example",
+ *   owner: {
+ *     name: "Bob",
+ *     bio: "Bob is a cool guy",
+ *  }
+ * };
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `title = "TOML Example"\n\n[owner]\nname = "Bob"\nbio = "Bob is a cool guy"\n`);
+ * ```
+ * @param obj Source object
+ * @param options Options for stringifying.
+ * @returns TOML string
+ */
+export declare function stringify(obj: Record<string, unknown>, options?: StringifyOptions): string;
+//# sourceMappingURL=stringify.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/stringify.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AA2OD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,CAER"}

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.js

@@ -0,0 +1,276 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+// Bare keys may only contain ASCII letters,
+// ASCII digits, underscores, and dashes (A-Za-z0-9_-).
+function joinKeys(keys) {
+    // Dotted keys are a sequence of bare or quoted keys joined with a dot.
+    // This allows for grouping similar properties together:
+    return keys
+        .map((str) => {
+        return str.length === 0 || str.match(/[^A-Za-z0-9_-]/)
+            ? JSON.stringify(str)
+            : str;
+    })
+        .join(".");
+}
+class Dumper {
+    maxPad = 0;
+    srcObject;
+    output = [];
+    #arrayTypeCache = new Map();
+    constructor(srcObjc) {
+        this.srcObject = srcObjc;
+    }
+    dump(fmtOptions = {}) {
+        // deno-lint-ignore no-explicit-any
+        this.output = this.#printObject(this.srcObject);
+        this.output = this.#format(fmtOptions);
+        return this.output;
+    }
+    #printObject(obj, keys = []) {
+        const out = [];
+        const props = Object.keys(obj);
+        const inlineProps = [];
+        const multilineProps = [];
+        for (const prop of props) {
+            if (this.#isSimplySerializable(obj[prop])) {
+                inlineProps.push(prop);
+            }
+            else {
+                multilineProps.push(prop);
+            }
+        }
+        const sortedProps = inlineProps.concat(multilineProps);
+        for (const prop of sortedProps) {
+            const value = obj[prop];
+            if (value instanceof Date) {
+                out.push(this.#dateDeclaration([prop], value));
+            }
+            else if (typeof value === "string" || value instanceof RegExp) {
+                out.push(this.#strDeclaration([prop], value.toString()));
+            }
+            else if (typeof value === "number") {
+                out.push(this.#numberDeclaration([prop], value));
+            }
+            else if (typeof value === "boolean") {
+                out.push(this.#boolDeclaration([prop], value));
+            }
+            else if (value instanceof Array) {
+                const arrayType = this.#getTypeOfArray(value);
+                if (arrayType === "ONLY_PRIMITIVE") {
+                    out.push(this.#arrayDeclaration([prop], value));
+                }
+                else if (arrayType === "ONLY_OBJECT_EXCLUDING_ARRAY") {
+                    // array of objects
+                    for (let i = 0; i < value.length; i++) {
+                        out.push("");
+                        out.push(this.#headerGroup([...keys, prop]));
+                        out.push(...this.#printObject(value[i], [...keys, prop]));
+                    }
+                }
+                else {
+                    // this is a complex array, use the inline format.
+                    const str = value.map((x) => this.#printAsInlineValue(x)).join(",");
+                    out.push(`${this.#declaration([prop])}[${str}]`);
+                }
+            }
+            else if (typeof value === "object") {
+                out.push("");
+                out.push(this.#header([...keys, prop]));
+                if (value) {
+                    const toParse = value;
+                    out.push(...this.#printObject(toParse, [...keys, prop]));
+                }
+                // out.push(...this._parse(value, `${path}${prop}.`));
+            }
+        }
+        out.push("");
+        return out;
+    }
+    #isPrimitive(value) {
+        return value instanceof Date ||
+            value instanceof RegExp ||
+            ["string", "number", "boolean"].includes(typeof value);
+    }
+    #getTypeOfArray(arr) {
+        if (this.#arrayTypeCache.has(arr)) {
+            return this.#arrayTypeCache.get(arr);
+        }
+        const type = this.#doGetTypeOfArray(arr);
+        this.#arrayTypeCache.set(arr, type);
+        return type;
+    }
+    #doGetTypeOfArray(arr) {
+        if (!arr.length) {
+            // any type should be fine
+            return "ONLY_PRIMITIVE";
+        }
+        const onlyPrimitive = this.#isPrimitive(arr[0]);
+        if (arr[0] instanceof Array) {
+            return "MIXED";
+        }
+        for (let i = 1; i < arr.length; i++) {
+            if (onlyPrimitive !== this.#isPrimitive(arr[i]) || arr[i] instanceof Array) {
+                return "MIXED";
+            }
+        }
+        return onlyPrimitive ? "ONLY_PRIMITIVE" : "ONLY_OBJECT_EXCLUDING_ARRAY";
+    }
+    #printAsInlineValue(value) {
+        if (value instanceof Date) {
+            return `"${this.#printDate(value)}"`;
+        }
+        else if (typeof value === "string" || value instanceof RegExp) {
+            return JSON.stringify(value.toString());
+        }
+        else if (typeof value === "number") {
+            return value;
+        }
+        else if (typeof value === "boolean") {
+            return value.toString();
+        }
+        else if (value instanceof Array) {
+            const str = value.map((x) => this.#printAsInlineValue(x)).join(",");
+            return `[${str}]`;
+        }
+        else if (typeof value === "object") {
+            if (!value) {
+                throw new Error("Should never reach");
+            }
+            const str = Object.keys(value).map((key) => {
+                return `${joinKeys([key])} = ${
+                // deno-lint-ignore no-explicit-any
+                this.#printAsInlineValue(value[key])}`;
+            }).join(",");
+            return `{${str}}`;
+        }
+        throw new Error("Should never reach");
+    }
+    #isSimplySerializable(value) {
+        return (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value instanceof RegExp ||
+            value instanceof Date ||
+            (value instanceof Array &&
+                this.#getTypeOfArray(value) !== "ONLY_OBJECT_EXCLUDING_ARRAY"));
+    }
+    #header(keys) {
+        return `[${joinKeys(keys)}]`;
+    }
+    #headerGroup(keys) {
+        return `[[${joinKeys(keys)}]]`;
+    }
+    #declaration(keys) {
+        const title = joinKeys(keys);
+        if (title.length > this.maxPad) {
+            this.maxPad = title.length;
+        }
+        return `${title} = `;
+    }
+    #arrayDeclaration(keys, value) {
+        return `${this.#declaration(keys)}${JSON.stringify(value)}`;
+    }
+    #strDeclaration(keys, value) {
+        return `${this.#declaration(keys)}${JSON.stringify(value)}`;
+    }
+    #numberDeclaration(keys, value) {
+        if (Number.isNaN(value)) {
+            return `${this.#declaration(keys)}nan`;
+        }
+        switch (value) {
+            case Infinity:
+                return `${this.#declaration(keys)}inf`;
+            case -Infinity:
+                return `${this.#declaration(keys)}-inf`;
+            default:
+                return `${this.#declaration(keys)}${value}`;
+        }
+    }
+    #boolDeclaration(keys, value) {
+        return `${this.#declaration(keys)}${value}`;
+    }
+    #printDate(value) {
+        function dtPad(v, lPad = 2) {
+            return v.padStart(lPad, "0");
+        }
+        const m = dtPad((value.getUTCMonth() + 1).toString());
+        const d = dtPad(value.getUTCDate().toString());
+        const h = dtPad(value.getUTCHours().toString());
+        const min = dtPad(value.getUTCMinutes().toString());
+        const s = dtPad(value.getUTCSeconds().toString());
+        const ms = dtPad(value.getUTCMilliseconds().toString(), 3);
+        // formatted date
+        const fData = `${value.getUTCFullYear()}-${m}-${d}T${h}:${min}:${s}.${ms}`;
+        return fData;
+    }
+    #dateDeclaration(keys, value) {
+        return `${this.#declaration(keys)}${this.#printDate(value)}`;
+    }
+    #format(options = {}) {
+        const { keyAlignment = false } = options;
+        const rDeclaration = /^(\".*\"|[^=]*)\s=/;
+        const out = [];
+        for (let i = 0; i < this.output.length; i++) {
+            const l = this.output[i];
+            // we keep empty entry for array of objects
+            if (l[0] === "[" && l[1] !== "[") {
+                // non-empty object with only subobjects as properties
+                if (this.output[i + 1] === "" &&
+                    this.output[i + 2]?.slice(0, l.length) === l.slice(0, -1) + ".") {
+                    i += 1;
+                    continue;
+                }
+                out.push(l);
+            }
+            else {
+                if (keyAlignment) {
+                    const m = rDeclaration.exec(l);
+                    if (m && m[1]) {
+                        out.push(l.replace(m[1], m[1].padEnd(this.maxPad)));
+                    }
+                    else {
+                        out.push(l);
+                    }
+                }
+                else {
+                    out.push(l);
+                }
+            }
+        }
+        // Cleaning multiple spaces
+        const cleanedOutput = [];
+        for (let i = 0; i < out.length; i++) {
+            const l = out[i];
+            if (!(l === "" && out[i + 1] === "")) {
+                cleanedOutput.push(l);
+            }
+        }
+        return cleanedOutput;
+    }
+}
+/**
+ * Converts an object to a {@link https://toml.io | TOML} string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/toml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   title: "TOML Example",
+ *   owner: {
+ *     name: "Bob",
+ *     bio: "Bob is a cool guy",
+ *  }
+ * };
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `title = "TOML Example"\n\n[owner]\nname = "Bob"\nbio = "Bob is a cool guy"\n`);
+ * ```
+ * @param obj Source object
+ * @param options Options for stringifying.
+ * @returns TOML string
+ */
+export function stringify(obj, options) {
+    return new Dumper(obj).dump(options).join("\n");
+}

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/index.d.ts

@@ -0,0 +1,5 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+export { z };
+export default z;
+//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@zod/zod/4.3.6/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,0BAA0B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,OAAO,EAAE,CAAC,EAAE,CAAC;AACb,eAAe,CAAC,CAAC"}

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/index.js

@@ -0,0 +1,4 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+export { z };
+export default z;

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/checks.d.ts

@@ -0,0 +1,2 @@
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";
+//# sourceMappingURL=checks.d.ts.map

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,IAAI,EAAE,EACT,IAAI,IAAI,GAAG,EACX,GAAG,IAAI,EAAE,EACT,IAAI,IAAI,GAAG,EACX,SAAS,IAAI,QAAQ,EACrB,SAAS,IAAI,QAAQ,EACrB,YAAY,IAAI,WAAW,EAC3B,YAAY,IAAI,WAAW,EAC3B,WAAW,IAAI,UAAU,EACzB,QAAQ,IAAI,OAAO,EACnB,QAAQ,IAAI,OAAO,EACnB,KAAK,IAAI,IAAI,EACb,UAAU,IAAI,SAAS,EACvB,UAAU,IAAI,SAAS,EACvB,OAAO,IAAI,MAAM,EACjB,MAAM,IAAI,KAAK,EACf,UAAU,IAAI,SAAS,EACvB,UAAU,IAAI,SAAS,EACvB,SAAS,IAAI,QAAQ,EACrB,WAAW,IAAI,UAAU,EACzB,SAAS,IAAI,QAAQ,EACrB,SAAS,IAAI,QAAQ,EACrB,KAAK,IAAI,IAAI,EACb,UAAU,IAAI,SAAS,EACvB,UAAU,IAAI,SAAS,EACvB,KAAK,IAAI,IAAI,EACb,YAAY,IAAI,WAAW,EAC3B,YAAY,IAAI,WAAW,EAC3B,QAAQ,IAAI,OAAO,EACnB,KAAK,cAAc,IAAI,aAAa,GACrC,MAAM,kBAAkB,CAAC"}

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/checks.js

@@ -0,0 +1 @@
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/coerce.d.ts

@@ -0,0 +1,18 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {
+}
+export declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;
+export interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {
+}
+export declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;
+export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {
+}
+export declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;
+export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {
+}
+export declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;
+export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {
+}
+export declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;
+//# sourceMappingURL=coerce.d.ts.map

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/coerce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerce.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/coerce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AACzC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAExC,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAAG;AACzG,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAEhG;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAAG;AACzG,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAEhG;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAAG;AAC5G,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAEnG;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAAG;AACzG,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAEhG;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAAG;AACnG,wBAAgB,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,CAE1F"}

package/esm/deps/jsr.io/@zod/zod/4.3.6/src/v4/classic/coerce.js

@@ -0,0 +1,17 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export function string(params) {
+    return core._coercedString(schemas.ZodString, params);
+}
+export function number(params) {
+    return core._coercedNumber(schemas.ZodNumber, params);
+}
+export function boolean(params) {
+    return core._coercedBoolean(schemas.ZodBoolean, params);
+}
+export function bigint(params) {
+    return core._coercedBigint(schemas.ZodBigInt, params);
+}
+export function date(params) {
+    return core._coercedDate(schemas.ZodDate, params);
+}