@lowlighter/is 1.3.3

package/README.md

@@ -0,0 +1,33 @@
+# 🪪 Is
+
+[![JSR](https://jsr.io/badges/@libs/is)](https://jsr.io/@libs/is) [![JSR Score](https://jsr.io/badges/@libs/is/score)](https://jsr.io/@libs/is)
+
+A wrapper around [Zod](https://zod.dev/) to ease type validation and assertions.
+
+It also contains some additional validators, in addition to a spec checker.
+
+- [`📚 Documentation`](https://jsr.io/@libs/is/doc)
+
+## 📖 Usage
+
+```ts
+import { coerce, duration, is, parse, url } from "@libs/is"
+
+// `is` re-exports Zod, augmented with additional validators and transformers
+const schema = is.object({
+  origin: url,
+  timeout: duration(is.number().min(0)),
+  retries: coerce(is.number().int().nonnegative()).default(3),
+})
+
+// `parse()` works like `schema.parse()` but throws a `TypeError` with prettified issues instead of a `ZodError`
+parse(schema, { origin: "https://example.com", timeout: "1m 30s", retries: "5" })
+// { origin: "https://example.com", timeout: 90000, retries: 5 }
+```
+
+## 📜 License
+
+```plaintext
+Copyright (c) Simon Lecoq <@lowlighter>. (MIT License)
+https://github.com/lowlighter/libs/blob/main/LICENSE
+```

package/is.d.ts

@@ -0,0 +1,40 @@
+import type { ParseOptions as ParseArgsOptions } from "@std/cli/parse-args";
+import * as is from "@zod/zod";
+export * as is from "@zod/zod";
+export type * from "@zod/zod";
+/** Coalesces a parsed value to `undefined` so schema defaults can be applied. */ export declare function coalesce<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Coerces a parsed value into `number` type when possible. */ export declare function coerce<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Allows the `null` value and makes it the default value in schemas. */ export declare function nullable<T extends is.ZodType>(schema: T): is.ZodDefault<is.ZodNullable<T>>;
+/** Ensures a parsed value is compatible with `structuredClone` algorithm. */ export declare function clonable<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Transforms a parsed value into an array if it is not already one. */ export declare function arrayable<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Transforms a CLI arguments string into an object or array. */ export declare function cliable<T extends is.ZodType>(schema: T, options?: ParseArgsOptions): is.ZodPreprocess<T>;
+/** Parses a regular expression back into a `RegExp`. */ export declare function regex<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Parses a date string back into a `Date`. */ export declare function date<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Parses a duration string into milliseconds. */ export declare function duration<T extends is.ZodType>(schema: T): is.ZodPreprocess<T>;
+/** Type alias for primitive values. */ export declare const primitive: is.ZodUnion<readonly [is.ZodString, is.ZodNumber, is.ZodBigInt, is.ZodBoolean, is.ZodUndefined, is.ZodNull, is.ZodDate, is.ZodCustom<Error, Error>]>;
+/** Type alias for typed arrays. */ export declare const typedArray: is.ZodUnion<readonly [is.ZodCustom<Int8Array, Int8Array>, is.ZodCustom<Uint8Array, Uint8Array>, is.ZodCustom<Uint8ClampedArray, Uint8ClampedArray>, is.ZodCustom<Int16Array, Int16Array>, is.ZodCustom<Uint16Array, Uint16Array>, is.ZodCustom<Int32Array, Int32Array>, is.ZodCustom<Uint32Array, Uint32Array>, is.ZodCustom<Float16Array, Float16Array>, is.ZodCustom<Float32Array, Float32Array>, is.ZodCustom<Float64Array, Float64Array>, is.ZodCustom<BigInt64Array, BigInt64Array>, is.ZodCustom<BigUint64Array, BigUint64Array>]>;
+/** Type alias for URLs with supported protocols. */ export declare const url: is.ZodURL & {
+  /** Create a new type alias for URLs with additional custom supported protocols. */ with(additional: string[], params?: Omit<is.z.core.$ZodURLParams, "protocol">): is.ZodURL;
+};
+/** Type alias for body init. */ export declare const bodyInit: is.ZodNullable<is.ZodUnion<readonly [is.ZodString, is.ZodCustom<String, String>, is.ZodCustom<Blob, Blob>, is.ZodCustom<ArrayBuffer, ArrayBuffer>, is.ZodCustom<DataView, DataView>, is.ZodCustom<FormData, FormData>, is.ZodCustom<ReadableStream, ReadableStream>, is.ZodCustom<URLSearchParams, URLSearchParams>, typeof typedArray]>>;
+/** Type alias factory for permissions object. */ export declare function permissions<T extends keyof Deno.PermissionOptionsObject>(options?: {
+  set?: T[];
+  expand?: false;
+}): is.ZodUnion<readonly [is.ZodObject<Record<T, is.ZodOptional<is.ZodPreprocess<is.ZodUnion<[is.ZodLiteral<"inherit">, is.ZodBoolean, is.ZodArray<is.ZodString>]>>>>>, is.ZodUnion<readonly [is.ZodLiteral<"inherit">, is.ZodLiteral<"none">]>]>;
+/** Type alias factory for permissions object. */ export declare function permissions<T extends keyof Deno.PermissionOptionsObject>(options: {
+  set?: T[];
+  expand: true;
+}): is.ZodPreprocess<is.ZodObject<Record<T, is.ZodPreprocess<is.ZodUnion<[is.ZodLiteral<"inherit">, is.ZodLiteral<true>, is.ZodArray<is.ZodString>]>>>>>;
+/** Type alias for expression strings. */ export declare const expression: is.ZodString;
+/** Type alias for callable values. */ export declare const callable: is.ZodCustom<Function, unknown>;
+/** Type alias for Zod schemas. */ export declare const parser: is.ZodCustom<is.ZodType, unknown>;
+/** Options for {@linkcode parse()}. */ export type ParseOptions = {
+  /** Whether to parse asynchronously. */ async?: boolean;
+  /** Whether to throw a `ZodError` rather than a `TypeError` in case of failure */ zodError?: boolean;
+};
+/** Parse a schema synchronously. */ export declare function parse<T extends is.ZodType>(schema: T, values: unknown, options?: Omit<ParseOptions, "async"> & {
+  async?: false;
+}): is.infer<T>;
+/** Parse a schema asynchronously. */ export declare function parse<T extends is.ZodType>(schema: T, values: unknown, options: Omit<ParseOptions, "async"> & {
+  async: true;
+}): Promise<is.infer<T>>;

package/is.js

@@ -0,0 +1,338 @@
+// Imports
+// deno-lint-ignore-file no-explicit-any ban-types
+import { parseArgs } from "@std/cli/parse-args";
+import * as is from "@zod/zod";
+export * as is from "@zod/zod";
+/** Coalesces a parsed value to `undefined` so schema defaults can be applied. */ export function coalesce(schema) {
+  return is.preprocess((value)=>{
+    return value ?? undefined;
+  }, schema);
+}
+/** Coerces a parsed value into `number` type when possible. */ export function coerce(schema) {
+  return is.preprocess((value)=>{
+    if (typeof value === "string") {
+      const coerced = Number(value);
+      if (!Number.isNaN(coerced) || value === "NaN") return coerced;
+    }
+    return value;
+  }, schema);
+}
+/** Allows the `null` value and makes it the default value in schemas. */ export function nullable(schema) {
+  return schema.nullable().default(null);
+}
+/** Ensures a parsed value is compatible with `structuredClone` algorithm. */ export function clonable(schema) {
+  return is.preprocess((value, context)=>{
+    try {
+      structuredClone(value);
+    } catch (error) {
+      context.addIssue(`Invalid input: Value must be compatible with structuredClone algorithm: ${error}`);
+    }
+    return value;
+  }, schema);
+}
+/** Transforms a parsed value into an array if it is not already one. */ export function arrayable(schema) {
+  return is.preprocess((value)=>{
+    if (!Array.isArray(value)) return [
+      value
+    ];
+    return value;
+  }, schema);
+}
+/** Transforms a CLI arguments string into an object or array. */ export function cliable(schema, options) {
+  return is.preprocess((value, context)=>{
+    if (typeof value === "string") {
+      const args = [];
+      let current = "";
+      let quoted = "";
+      let escape = false;
+      let quotes = false;
+      for (const char of value){
+        if (escape) {
+          current += char;
+          escape = false;
+          continue;
+        }
+        if (quoted === '"' && char === "\\") {
+          escape = true;
+          continue;
+        }
+        if (!quoted && (char === '"' || char === "'")) {
+          quoted = char;
+          quotes = true;
+          continue;
+        }
+        if (quoted === char) {
+          quoted = "";
+          continue;
+        }
+        if (!quoted && char === " ") {
+          if (current || quotes) {
+            args.push(current);
+            current = "";
+            quotes = false;
+          }
+          continue;
+        }
+        current += char;
+      }
+      if (quoted) {
+        context.addIssue(`Unclosed quote: ${quoted}${current}`);
+        return value;
+      }
+      if (current || quotes) args.push(current);
+      return options ? parseArgs(args, options) : args;
+    }
+    return value;
+  }, schema);
+}
+/** Parses a regular expression back into a `RegExp`. */ export function regex(schema) {
+  const definition = /^\/(?<pattern>.*?)\/(?<flags>[dgimsuvy]*)$/s;
+  return is.preprocess((value)=>{
+    if (typeof value === "string") {
+      const groups = value.match(definition)?.groups;
+      if (groups) {
+        const { pattern, flags } = groups;
+        try {
+          return new RegExp(pattern, flags);
+        } catch  {
+          return value;
+        }
+      }
+    }
+    return value;
+  }, schema);
+}
+/** Parses a date string back into a `Date`. */ export function date(schema) {
+  return is.preprocess((value)=>{
+    if (typeof value === "string") {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) return date;
+    }
+    return value;
+  }, schema);
+}
+/** Parses a duration string into milliseconds. */ export function duration(schema) {
+  return is.preprocess((value)=>{
+    if (typeof value === "string") {
+      const groups = value.match(/^\s*(?:(?<days>\d+)d(?:ays?)?)?\s*(?:(?<hours>\d+)h(?:(?:ou)?rs?)?)?\s*(?:(?<minutes>\d+)m(?:in(?:ute)?s?)?)?\s*(?:(?<seconds>\d+)s(?:ec(?:ond)?s?)?)?\s*(?:(?<milliseconds>\d+)(?:m(?:illi)?s(?:ec(?:ond)?s?)?)?)?\s*$/)?.groups;
+      if (groups) {
+        let { days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0 } = Object.fromEntries(Object.entries(groups).map(([key, value])=>[
+            key,
+            Number(value)
+          ]).filter(([_, value])=>Number.isFinite(value)));
+        hours += days * 24;
+        minutes += hours * 60;
+        seconds += minutes * 60;
+        milliseconds += seconds * 1000;
+        return milliseconds;
+      }
+    }
+    return value;
+  }, schema);
+}
+/** Type alias for primitive values. */ export const primitive = is.union([
+  is.string(),
+  is.number(),
+  is.bigint(),
+  is.boolean(),
+  is.undefined(),
+  is.null(),
+  is.date(),
+  is.instanceof(Error)
+]);
+/** Type alias for typed arrays. */ export const typedArray = is.union([
+  is.instanceof(Int8Array),
+  is.instanceof(Uint8Array),
+  is.instanceof(Uint8ClampedArray),
+  is.instanceof(Int16Array),
+  is.instanceof(Uint16Array),
+  is.instanceof(Int32Array),
+  is.instanceof(Uint32Array),
+  is.instanceof(Float16Array),
+  is.instanceof(Float32Array),
+  is.instanceof(Float64Array),
+  is.instanceof(BigInt64Array),
+  is.instanceof(BigUint64Array)
+]);
+/** Supported protocols for {@linkcode url} type alias. */ const protocols = [
+  "https?",
+  "file",
+  "wasm",
+  "data",
+  "blob",
+  "jsr",
+  "npm"
+];
+/** Type alias for URLs with supported protocols. */ export const url = Object.assign(is.url({
+  protocol: new RegExp(`^(?:${protocols.join("|")})$`),
+  hostname: /.*/
+}), {
+  with (additional, { hostname = /.*/, ...options } = {}) {
+    const escaped = additional.map((protocol)=>protocol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    return is.url({
+      ...options,
+      protocol: new RegExp(`^(?:${[
+        ...protocols,
+        ...escaped
+      ].join("|")})$`),
+      hostname
+    });
+  }
+});
+/** Type alias for body init. */ export const bodyInit = is.union([
+  is.string(),
+  is.instanceof(String),
+  is.instanceof(Blob),
+  is.instanceof(ArrayBuffer),
+  is.instanceof(DataView),
+  is.instanceof(FormData),
+  is.instanceof(ReadableStream),
+  is.instanceof(URLSearchParams),
+  typedArray
+]).nullable();
+/**
+ * System permissions flags.
+ *
+ * See {@link https://docs.deno.com/runtime/fundamentals/security/#system-information}.
+ */ const sysflags = [
+  "hostname",
+  "osRelease",
+  "osUptime",
+  "loadavg",
+  "networkInterfaces",
+  "systemMemoryInfo",
+  "uid",
+  "gid"
+];
+/** Type alias factory for permission descriptors. */ function permission({ expand = false, urls = false, sys = false } = {}) {
+  return is.preprocess((value)=>{
+    if (value === "inherit") return value;
+    if (typeof value === "string") value = [
+      value
+    ];
+    if (expand) {
+      if (value === undefined || value === false) value = [];
+    }
+    if (urls && Array.isArray(value)) value = value.map((value)=>value instanceof URL ? value.href : value);
+    return value;
+  }, is.union([
+    is.literal("inherit"),
+    is.boolean(),
+    is.array(sys ? is.enum(sysflags) : is.string())
+  ]));
+}
+export function permissions({ set = [
+  "read",
+  "write",
+  "net",
+  "env",
+  "run",
+  "sys",
+  "ffi",
+  "import"
+], expand = false } = {}) {
+  const validator = is.object({
+    read: permission({
+      expand,
+      urls: true
+    }),
+    write: permission({
+      expand,
+      urls: true
+    }),
+    net: permission({
+      expand
+    }),
+    env: permission({
+      expand
+    }),
+    sys: permission({
+      expand,
+      sys: true
+    }),
+    run: permission({
+      expand,
+      urls: true
+    }),
+    ffi: permission({
+      expand,
+      urls: true
+    }),
+    import: permission({
+      expand
+    })
+  }).pick(Object.fromEntries(set.map((key)=>[
+      key,
+      true
+    ]))).strict();
+  // Return either the compact or expanded version
+  if (!expand) return validator.partial().or(is.union([
+    is.literal("inherit"),
+    is.literal("none")
+  ]));
+  return is.preprocess((value)=>{
+    if (value === "inherit" || value === "none") return Object.fromEntries(set.map((key)=>[
+        key,
+        value === "none" ? [] : value
+      ]));
+    if (typeof value === "string") value = [
+      value
+    ];
+    if (Array.isArray(value)) return {
+      ...Object.fromEntries(set.map((permission)=>[
+          permission,
+          false
+        ])),
+      ...Object.fromEntries(value.map((permission)=>[
+          permission,
+          "inherit"
+        ]))
+    };
+    return value;
+  }, validator);
+}
+/** Type alias for expression strings. */ export const expression = is.string().regex(/\$\{.*\}/);
+/** Type alias for callable values. */ export const callable = is.unknown().refine((value)=>typeof value === "function", {
+  message: "Invalid input: Value must be callable"
+});
+/** Type alias for Zod schemas. */ export const parser = is.custom((value)=>value instanceof is.ZodType || value && typeof value === "object" && typeof value.parse === "function", {
+  message: "Invalid input: Value must be a Zod schema"
+});
+/** Convert a property key path to a string. */ function toPath(path = []) {
+  const segments = [];
+  for (const segment of path){
+    if (typeof segment === "number") segments.push(`[${segment}]`);
+    else if (typeof segment === "symbol" || /[^\w$]/.test(String(segment))) segments.push(`[${JSON.stringify(String(segment))}]`);
+    else segments.push(`.${segment}`);
+  }
+  return segments.join("");
+}
+/** Prettify validation issues in a more detailed way. */ function prettifyIssue(errors, { indent = "" } = {}) {
+  const lines = [];
+  errors = [
+    ...errors
+  ].sort((a, b)=>(a.path ?? []).length - (b.path ?? []).length);
+  for (const error of errors){
+    lines.push(`${indent}✘ ${error.message}`);
+    if (error.path?.length) lines.push(`${indent}  → at ${toPath(error.path)}`);
+    if (error.errors?.length) {
+      lines.push(`${indent}  → tried to fit into one of the allowed types:`);
+      for (const suberror of error.errors)lines.push(prettifyIssue(suberror, {
+        indent: `${indent}      `
+      }).replace("  ✘", "- ✘"));
+    }
+  }
+  return lines.join("\n");
+}
+export function parse(schema, values, { async = false, zodError } = {}) {
+  try {
+    return async ? schema.parseAsync(values).catch((error)=>{
+      if (!(error instanceof is.ZodError) || zodError) throw error;
+      throw new TypeError(`Validation failed: \n${prettifyIssue(error.issues)}`);
+    }) : schema.parse(values);
+  } catch (error) {
+    if (!(error instanceof is.ZodError) || zodError) throw error;
+    throw new TypeError(`Validation failed: \n${prettifyIssue(error.issues)}`);
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/is/is.ts"],"sourcesContent":["// Imports\n// deno-lint-ignore-file no-explicit-any ban-types\nimport type { ParseOptions as ParseArgsOptions } from \"@std/cli/parse-args\"\nimport { parseArgs } from \"@std/cli/parse-args\"\nimport * as is from \"@zod/zod\"\nexport * as is from \"@zod/zod\"\nexport type * from \"@zod/zod\"\n\n/** Coalesces a parsed value to `undefined` so schema defaults can be applied. */\nexport function coalesce<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value) => {\n    return value ?? undefined\n  }, schema)\n}\n\n/** Coerces a parsed value into `number` type when possible. */\nexport function coerce<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value) => {\n    if (typeof value === \"string\") {\n      const coerced = Number(value)\n      if ((!Number.isNaN(coerced)) || (value === \"NaN\"))\n        return coerced\n    }\n    return value\n  }, schema)\n}\n\n/** Allows the `null` value and makes it the default value in schemas. */\nexport function nullable<T extends is.ZodType>(schema: T): is.ZodDefault<is.ZodNullable<T>> {\n  return schema.nullable().default(null)\n}\n\n/** Ensures a parsed value is compatible with `structuredClone` algorithm. */\nexport function clonable<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value, context) => {\n    try {\n      structuredClone(value)\n    } catch (error) {\n      context.addIssue(`Invalid input: Value must be compatible with structuredClone algorithm: ${error}`)\n    }\n    return value\n  }, schema)\n}\n\n/** Transforms a parsed value into an array if it is not already one. */\nexport function arrayable<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value) => {\n    if (!Array.isArray(value))\n      return [value]\n    return value\n  }, schema)\n}\n\n/** Transforms a CLI arguments string into an object or array. */\nexport function cliable<T extends is.ZodType>(schema: T, options?: ParseArgsOptions): is.ZodPreprocess<T> {\n  return is.preprocess((value, context) => {\n    if (typeof value === \"string\") {\n      const args = []\n      let current = \"\"\n      let quoted = \"\"\n      let escape = false\n      let quotes = false\n      for (const char of value) {\n        if (escape) {\n          current += char\n          escape = false\n          continue\n        }\n        if ((quoted === '\"') && (char === \"\\\\\")) {\n          escape = true\n          continue\n        }\n        if ((!quoted) && ((char === '\"') || (char === \"'\"))) {\n          quoted = char\n          quotes = true\n          continue\n        }\n        if (quoted === char) {\n          quoted = \"\"\n          continue\n        }\n        if ((!quoted) && (char === \" \")) {\n          if (current || quotes) {\n            args.push(current)\n            current = \"\"\n            quotes = false\n          }\n          continue\n        }\n        current += char\n      }\n      if (quoted) {\n        context.addIssue(`Unclosed quote: ${quoted}${current}`)\n        return value\n      }\n      if (current || quotes)\n        args.push(current)\n      return options ? parseArgs(args, options) : args\n    }\n    return value\n  }, schema)\n}\n\n/** Parses a regular expression back into a `RegExp`. */\nexport function regex<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  const definition = /^\\/(?<pattern>.*?)\\/(?<flags>[dgimsuvy]*)$/s\n  return is.preprocess((value) => {\n    if (typeof value === \"string\") {\n      const groups = value.match(definition)?.groups\n      if (groups) {\n        const { pattern, flags } = groups\n        try {\n          return new RegExp(pattern, flags)\n        } catch {\n          return value\n        }\n      }\n    }\n    return value\n  }, schema)\n}\n\n/** Parses a date string back into a `Date`. */\nexport function date<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value) => {\n    if (typeof value === \"string\") {\n      const date = new Date(value)\n      if (!Number.isNaN(date.getTime()))\n        return date\n    }\n    return value\n  }, schema)\n}\n\n/** Parses a duration string into milliseconds. */\nexport function duration<T extends is.ZodType>(schema: T): is.ZodPreprocess<T> {\n  return is.preprocess((value) => {\n    if (typeof value === \"string\") {\n      const groups = value.match(/^\\s*(?:(?<days>\\d+)d(?:ays?)?)?\\s*(?:(?<hours>\\d+)h(?:(?:ou)?rs?)?)?\\s*(?:(?<minutes>\\d+)m(?:in(?:ute)?s?)?)?\\s*(?:(?<seconds>\\d+)s(?:ec(?:ond)?s?)?)?\\s*(?:(?<milliseconds>\\d+)(?:m(?:illi)?s(?:ec(?:ond)?s?)?)?)?\\s*$/)?.groups\n      if (groups) {\n        let { days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0 } = Object.fromEntries(Object.entries(groups).map(([key, value]) => [key, Number(value)]).filter(([_, value]) => Number.isFinite(value)))\n        hours += days * 24\n        minutes += hours * 60\n        seconds += minutes * 60\n        milliseconds += seconds * 1000\n        return milliseconds\n      }\n    }\n    return value\n  }, schema)\n}\n\n/** Type alias for primitive values. */\nexport const primitive = is.union([is.string(), is.number(), is.bigint(), is.boolean(), is.undefined(), is.null(), is.date(), is.instanceof(Error)]) as is.ZodUnion<\n  readonly [is.ZodString, is.ZodNumber, is.ZodBigInt, is.ZodBoolean, is.ZodUndefined, is.ZodNull, is.ZodDate, is.ZodCustom<Error, Error>]\n>\n\n/** Type alias for typed arrays. */\nexport const typedArray = is.union([\n  is.instanceof(Int8Array),\n  is.instanceof(Uint8Array),\n  is.instanceof(Uint8ClampedArray),\n  is.instanceof(Int16Array),\n  is.instanceof(Uint16Array),\n  is.instanceof(Int32Array),\n  is.instanceof(Uint32Array),\n  is.instanceof(Float16Array),\n  is.instanceof(Float32Array),\n  is.instanceof(Float64Array),\n  is.instanceof(BigInt64Array),\n  is.instanceof(BigUint64Array),\n]) as is.ZodUnion<\n  readonly [\n    is.ZodCustom<Int8Array, Int8Array>,\n    is.ZodCustom<Uint8Array, Uint8Array>,\n    is.ZodCustom<Uint8ClampedArray, Uint8ClampedArray>,\n    is.ZodCustom<Int16Array, Int16Array>,\n    is.ZodCustom<Uint16Array, Uint16Array>,\n    is.ZodCustom<Int32Array, Int32Array>,\n    is.ZodCustom<Uint32Array, Uint32Array>,\n    is.ZodCustom<Float16Array, Float16Array>,\n    is.ZodCustom<Float32Array, Float32Array>,\n    is.ZodCustom<Float64Array, Float64Array>,\n    is.ZodCustom<BigInt64Array, BigInt64Array>,\n    is.ZodCustom<BigUint64Array, BigUint64Array>,\n  ]\n>\n\n/** Supported protocols for {@linkcode url} type alias. */\nconst protocols = [\"https?\", \"file\", \"wasm\", \"data\", \"blob\", \"jsr\", \"npm\"]\n\n/** Type alias for URLs with supported protocols. */\nexport const url = Object.assign(is.url({ protocol: new RegExp(`^(?:${protocols.join(\"|\")})$`), hostname: /.*/ }), {\n  with(additional: string[], { hostname = /.*/, ...options }: Omit<is.z.core.$ZodURLParams, \"protocol\"> = {}) {\n    const escaped = additional.map((protocol) => protocol.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"))\n    return is.url({ ...options, protocol: new RegExp(`^(?:${[...protocols, ...escaped].join(\"|\")})$`), hostname })\n  },\n}) as is.ZodURL & {\n  /** Create a new type alias for URLs with additional custom supported protocols. */\n  with(additional: string[], params?: Omit<is.z.core.$ZodURLParams, \"protocol\">): is.ZodURL\n}\n\n/** Type alias for body init. */\nexport const bodyInit = is.union([\n  is.string(),\n  is.instanceof(String),\n  is.instanceof(Blob),\n  is.instanceof(ArrayBuffer),\n  is.instanceof(DataView),\n  is.instanceof(FormData),\n  is.instanceof(ReadableStream),\n  is.instanceof(URLSearchParams),\n  typedArray,\n]).nullable() as is.ZodNullable<\n  is.ZodUnion<\n    readonly [\n      is.ZodString,\n      is.ZodCustom<String, String>,\n      is.ZodCustom<Blob, Blob>,\n      is.ZodCustom<ArrayBuffer, ArrayBuffer>,\n      is.ZodCustom<DataView, DataView>,\n      is.ZodCustom<FormData, FormData>,\n      is.ZodCustom<ReadableStream, ReadableStream>,\n      is.ZodCustom<URLSearchParams, URLSearchParams>,\n      typeof typedArray,\n    ]\n  >\n>\n\n/**\n * System permissions flags.\n *\n * See {@link https://docs.deno.com/runtime/fundamentals/security/#system-information}.\n */\nconst sysflags = [\"hostname\", \"osRelease\", \"osUptime\", \"loadavg\", \"networkInterfaces\", \"systemMemoryInfo\", \"uid\", \"gid\"] as const\n\n/** Type alias factory for permission descriptors. */\nfunction permission({ expand = false, urls = false, sys = false } = {}) {\n  return is.preprocess((value) => {\n    if (value === \"inherit\")\n      return value\n    if (typeof value === \"string\")\n      value = [value]\n    if (expand) {\n      if ((value === undefined) || (value === false))\n        value = []\n    }\n    if (urls && Array.isArray(value))\n      value = value.map((value) => value instanceof URL ? value.href : value)\n    return value\n  }, is.union([is.literal(\"inherit\"), is.boolean(), is.array(sys ? is.enum(sysflags) : is.string())]))\n}\n\n/** Type alias factory for permissions object. */\nexport function permissions<T extends keyof Deno.PermissionOptionsObject>(\n  options?: { set?: T[]; expand?: false },\n): is.ZodUnion<readonly [is.ZodObject<Record<T, is.ZodOptional<is.ZodPreprocess<is.ZodUnion<[is.ZodLiteral<\"inherit\">, is.ZodBoolean, is.ZodArray<is.ZodString>]>>>>>, is.ZodUnion<readonly [is.ZodLiteral<\"inherit\">, is.ZodLiteral<\"none\">]>]>\n/** Type alias factory for permissions object. */\nexport function permissions<T extends keyof Deno.PermissionOptionsObject>(\n  options: { set?: T[]; expand: true },\n): is.ZodPreprocess<is.ZodObject<Record<T, is.ZodPreprocess<is.ZodUnion<[is.ZodLiteral<\"inherit\">, is.ZodLiteral<true>, is.ZodArray<is.ZodString>]>>>>>\nexport function permissions<T extends keyof Deno.PermissionOptionsObject>({ set = [\"read\", \"write\", \"net\", \"env\", \"run\", \"sys\", \"ffi\", \"import\"] as T[], expand = false }: { set?: T[]; expand?: boolean } = {}) {\n  const validator = is.object({\n    read: permission({ expand, urls: true }),\n    write: permission({ expand, urls: true }),\n    net: permission({ expand }),\n    env: permission({ expand }),\n    sys: permission({ expand, sys: true }),\n    run: permission({ expand, urls: true }),\n    ffi: permission({ expand, urls: true }),\n    import: permission({ expand }),\n  }).pick<any>(Object.fromEntries(set.map((key) => [key, true]))).strict()\n\n  // Return either the compact or expanded version\n  if (!expand)\n    return validator.partial().or(is.union([is.literal(\"inherit\"), is.literal(\"none\")]))\n  return is.preprocess((value) => {\n    if ((value === \"inherit\") || (value === \"none\"))\n      return Object.fromEntries(set.map((key) => [key, value === \"none\" ? [] : value]))\n    if (typeof value === \"string\")\n      value = [value]\n    if (Array.isArray(value))\n      return { ...Object.fromEntries(set.map((permission) => [permission, false])), ...Object.fromEntries(value.map((permission) => [permission, \"inherit\"])) }\n    return value\n  }, validator) as unknown\n}\n\n/** Type alias for expression strings. */\nexport const expression = is.string().regex(/\\$\\{.*\\}/) as is.ZodString\n\n/** Type alias for callable values. */\nexport const callable = is.unknown().refine((value) => typeof value === \"function\", { message: \"Invalid input: Value must be callable\" }) as unknown as is.ZodCustom<Function, unknown>\n\n/** Type alias for Zod schemas. */\nexport const parser = is.custom((value) => (value instanceof is.ZodType) || (value && (typeof value === \"object\") && (typeof (value as Record<PropertyKey, unknown>).parse === \"function\")), { message: \"Invalid input: Value must be a Zod schema\" }) as is.ZodCustom<\n  is.ZodType,\n  unknown\n>\n\n/** Object that ressemble a ZodError. */\ntype ZodErrorLike = { path?: PropertyKey[]; message: string; errors?: ZodErrorLike[][] }\n\n/** Convert a property key path to a string. */\nfunction toPath(path: PropertyKey[] = []): string {\n  const segments = []\n  for (const segment of path) {\n    if (typeof segment === \"number\")\n      segments.push(`[${segment}]`)\n    else if (typeof segment === \"symbol\" || /[^\\w$]/.test(String(segment)))\n      segments.push(`[${JSON.stringify(String(segment))}]`)\n    else\n      segments.push(`.${segment}`)\n  }\n  return segments.join(\"\")\n}\n\n/** Prettify validation issues in a more detailed way. */\nfunction prettifyIssue(errors: ZodErrorLike[], { indent = \"\" } = {}): string {\n  const lines = []\n  errors = [...errors].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length)\n  for (const error of errors) {\n    lines.push(`${indent}✘ ${error.message}`)\n    if (error.path?.length)\n      lines.push(`${indent}  → at ${toPath(error.path)}`)\n    if (error.errors?.length) {\n      lines.push(`${indent}  → tried to fit into one of the allowed types:`)\n      for (const suberror of error.errors)\n        lines.push(prettifyIssue(suberror, { indent: `${indent}      ` }).replace(\"  ✘\", \"- ✘\"))\n    }\n  }\n  return lines.join(\"\\n\")\n}\n\n/** Options for {@linkcode parse()}. */\nexport type ParseOptions = {\n  /** Whether to parse asynchronously. */\n  async?: boolean\n  /** Whether to throw a `ZodError` rather than a `TypeError` in case of failure */\n  zodError?: boolean\n}\n\n/** Parse a schema synchronously. */\nexport function parse<T extends is.ZodType>(schema: T, values: unknown, options?: Omit<ParseOptions, \"async\"> & { async?: false }): is.infer<T>\n/** Parse a schema asynchronously. */\nexport function parse<T extends is.ZodType>(schema: T, values: unknown, options: Omit<ParseOptions, \"async\"> & { async: true }): Promise<is.infer<T>>\nexport function parse<T extends is.ZodType>(schema: T, values: unknown, { async = false, zodError }: ParseOptions = {}) {\n  try {\n    return async\n      ? schema.parseAsync(values).catch((error) => {\n        if ((!(error instanceof is.ZodError)) || zodError)\n          throw error\n        throw new TypeError(`Validation failed: \\n${prettifyIssue(error.issues)}`)\n      })\n      : schema.parse(values)\n  } catch (error) {\n    if ((!(error instanceof is.ZodError)) || zodError)\n      throw error\n    throw new TypeError(`Validation failed: \\n${prettifyIssue(error.issues)}`)\n  }\n}\n"],"names":[],"mappings":"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"}

package/mod.d.ts

@@ -0,0 +1 @@
+export * from "./is.js";

package/mod.js

@@ -0,0 +1,2 @@
+export * from "./is.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvaXMvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2lzLmpzXCJcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVMifQ==

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@lowlighter/is",
+  "version": "1.3.3",
+  "type": "module",
+  "main": "./mod.js",
+  "types": "./mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./mod.d.ts",
+      "import": "./mod.js",
+      "default": "./mod.js"
+    },
+    "./testing": {
+      "types": "./testing/mod.d.ts",
+      "import": "./testing/mod.js",
+      "default": "./testing/mod.js"
+    }
+  },
+  "dependencies": {
+    "@jsr/std__cli": "^1.0.28",
+    "@jsr/std__collections": "^1.1.6",
+    "@jsr/zod__zod": "^4.4.3",
+    "@lowlighter/testing": "^6.0.0"
+  }
+}

package/testing/mod.d.ts

@@ -0,0 +1 @@
+export * from "./spec.js";

package/testing/mod.js

@@ -0,0 +1,2 @@
+export * from "./spec.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvaXMvdGVzdGluZy9tb2QudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vc3BlYy5qc1wiXG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFXIn0=

package/testing/spec.d.ts

@@ -0,0 +1,48 @@
+import { is } from "../is.js";
+/** Test case definition. */ export type testcase = {
+  a: unknown;
+  b?: unknown;
+  env?: Record<string, string>;
+};
+/** Configuration options for {@linkcode spec()}. */ export type SpecOptions = {
+  /** Whether to perform a prefault check. */ prefault?: boolean;
+  /** Whether to perform a strictness check. */ strict?: boolean;
+  /** Setup function to run before tests. */ setup?: () => void;
+};
+/** Specification check helper. */ export declare const spec: ((name: string, schema: is.ZodType, testsuites: Array<testcase> | Record<PropertyKey, Array<testcase>>, options?: SpecOptions) => void) & {
+  optional: Array<testcase>;
+  nullable: Array<testcase>;
+  primitive: Array<testcase>;
+  boolean: Array<testcase>;
+  string: {
+    arrayable: Array<testcase>;
+  } & Array<testcase>;
+  positive: {
+    int: Array<testcase>;
+    finite: Array<testcase>;
+    infinity: Array<testcase>;
+  };
+  record: {
+    primitive: Array<testcase>;
+  } & Array<testcase>;
+  array: {
+    unique: Array<testcase>;
+    typed: Array<testcase>;
+  };
+  response: {
+    body: {
+      init: Array<testcase>;
+    };
+  };
+  ulid: Array<testcase>;
+  url: Array<testcase>;
+  date: Array<testcase>;
+  error: Array<testcase>;
+  expression: Array<testcase>;
+  callable: Array<testcase>;
+  parser: Array<testcase>;
+  unknown: Array<testcase>;
+  meta: (meta: ImportMeta) => Array<testcase>;
+  enum: (values: readonly string[]) => Array<testcase>;
+  default: (b: unknown, options?: Omit<testcase, "a" | "b">) => Array<testcase>;
+};

package/testing/spec.js

@@ -0,0 +1,504 @@
+// Imports
+import { is } from "../is.js";
+import { pick } from "@std/collections";
+import { expect } from "@lowlighter/testing";
+import { inspect } from "@lowlighter/testing/highlight";
+/** Specification check helper. */ export const spec = Object.assign(function(name, schema, testsuites, { prefault = true, strict = true, setup } = {}) {
+  if (Array.isArray(testsuites)) testsuites = {
+    "*": testsuites
+  };
+  // Prefault check
+  if (prefault) Deno.test(`\`${name}.parse()\` has prefault`, ()=>expect(schema.parse(undefined)).toMatchObject({}));
+  // Strictness check
+  if (strict) Deno.test(`\`${name}.parse()\` is strict`, ()=>expect(()=>schema.parse({
+        __strictness_test__: true
+      })).toThrow());
+  // Parsing checks
+  for (const [key, testcases] of Object.entries(testsuites)){
+    for (const testcase of testcases){
+      const a = key === "*" ? testcase.a : {
+        [key]: testcase.a
+      };
+      const b = "b" in testcase ? testcase.b : testcase.a;
+      Deno.test(`\`${name}.parse(${inspect(a)})\` ${b === Error ? "throws error" : `is parsed${"b" in testcase ? ` as \`${inspect(b)}\`` : ""}`}${"env" in testcase ? ` with \`${inspect(testcase.env)}\`` : ""}`, {
+        permissions: {
+          env: testcase.env ? true : false
+        }
+      }, ()=>{
+        const env = {};
+        try {
+          setup?.();
+          // Apply environment variables
+          if (testcase.env) {
+            for (const [key, value] of Object.entries(testcase.env)){
+              if (Deno.env.has(key)) env[key] = Deno.env.get(key);
+              Deno.env.set(key, value);
+            }
+          }
+          // Apply test
+          if (b === Error) expect(()=>schema.parse(a)).toThrow();
+          else {
+            if (key === "*" && (typeof b !== "object" || b === null)) {
+              expect(schema.parse(a)).toEqual(b);
+              return;
+            }
+            if (b instanceof Date || b === "2024-01-01T00:00:00.000Z") {
+              const da = schema.parse(a);
+              expect((key === "*" ? da : da[key]).getTime()).toBe(new Date(b).getTime());
+              return;
+            }
+            expect(schema.parse(a)).toMatchObject(key === "*" ? b : {
+              [key]: b
+            });
+          }
+        } finally{
+          for (const [key, value] of Object.entries(env))Deno.env.set(key, value);
+        }
+      });
+    }
+  }
+}, {
+  optional: [
+    {
+      a: undefined,
+      b: undefined
+    }
+  ],
+  nullable: [
+    {
+      a: null
+    }
+  ],
+  primitive: [
+    {
+      a: "foo"
+    },
+    {
+      a: 123
+    },
+    {
+      a: 123n
+    },
+    {
+      a: true
+    },
+    {
+      a: undefined
+    },
+    {
+      a: null
+    },
+    {
+      a: new Date("2024-01-01T00:00:00.000Z")
+    },
+    {
+      a: new Error("Testing")
+    },
+    {
+      a: Symbol.for("@@testing"),
+      b: Error
+    },
+    {
+      a: {},
+      b: Error
+    },
+    {
+      a: [],
+      b: Error
+    },
+    {
+      a: function() {},
+      b: Error
+    }
+  ],
+  boolean: [
+    {
+      a: true
+    },
+    {
+      a: false
+    }
+  ],
+  string: Object.assign([
+    {
+      a: "foo"
+    }
+  ], {
+    arrayable: [
+      {
+        a: "a",
+        b: [
+          "a"
+        ]
+      },
+      {
+        a: [
+          "a",
+          "b"
+        ],
+        b: [
+          "a",
+          "b"
+        ]
+      }
+    ]
+  }),
+  positive: {
+    int: [
+      {
+        a: 1
+      },
+      {
+        a: "1",
+        b: 1
+      },
+      {
+        a: -1,
+        b: Error
+      },
+      {
+        a: "-1",
+        b: Error
+      },
+      {
+        a: "NaN",
+        b: Error
+      }
+    ],
+    finite: [
+      {
+        a: 1
+      },
+      {
+        a: NaN,
+        b: Error
+      },
+      {
+        a: Infinity,
+        b: Error
+      }
+    ],
+    infinity: [
+      {
+        a: Infinity
+      },
+      {
+        a: "Infinity",
+        b: Infinity
+      }
+    ]
+  },
+  record: Object.assign([
+    {
+      a: {
+        foo: "bar",
+        baz: 123
+      },
+      b: {
+        foo: "bar",
+        baz: 123
+      }
+    },
+    {
+      a: "foo",
+      b: Error
+    }
+  ], {
+    primitive: [
+      {
+        a: {
+          foo: "bar"
+        }
+      },
+      {
+        a: {
+          foo: 123
+        }
+      },
+      {
+        a: {
+          foo: 123n
+        }
+      },
+      {
+        a: {
+          foo: true
+        }
+      },
+      {
+        a: {
+          foo: undefined
+        }
+      },
+      {
+        a: {
+          foo: null
+        }
+      },
+      {
+        a: {
+          foo: Symbol.for("@@testing")
+        },
+        b: Error
+      },
+      {
+        a: {
+          foo: {}
+        },
+        b: Error
+      },
+      {
+        a: {
+          foo: []
+        },
+        b: Error
+      },
+      {
+        a: {
+          foo: function() {}
+        },
+        b: Error
+      }
+    ]
+  }),
+  array: {
+    unique: [
+      {
+        a: [
+          "a",
+          "b",
+          "b",
+          "a",
+          "c"
+        ],
+        b: [
+          "a",
+          "b",
+          "c"
+        ]
+      }
+    ],
+    typed: [
+      {
+        a: new Int8Array()
+      },
+      {
+        a: new Uint8Array()
+      },
+      {
+        a: new Uint8ClampedArray()
+      },
+      {
+        a: new Int16Array()
+      },
+      {
+        a: new Uint16Array()
+      },
+      {
+        a: new Int32Array()
+      },
+      {
+        a: new Uint32Array()
+      },
+      {
+        a: new Float16Array()
+      },
+      {
+        a: new Float32Array()
+      },
+      {
+        a: new Float64Array()
+      },
+      {
+        a: new BigInt64Array()
+      },
+      {
+        a: new BigUint64Array()
+      }
+    ]
+  },
+  response: {
+    body: {
+      init: [
+        {
+          a: null
+        },
+        {
+          a: "foo"
+        },
+        {
+          a: new Blob()
+        },
+        {
+          a: new ArrayBuffer(8)
+        },
+        {
+          a: new DataView(new ArrayBuffer(8))
+        },
+        {
+          a: new FormData()
+        },
+        {
+          a: new ReadableStream()
+        },
+        {
+          a: new URLSearchParams()
+        },
+        {
+          a: new Int8Array()
+        }
+      ]
+    }
+  },
+  ulid: [
+    {
+      a: "0".repeat(26)
+    },
+    {
+      a: "TEST_INVALID_ULID",
+      b: Error
+    }
+  ],
+  url: [
+    {
+      a: "http://example.com"
+    },
+    {
+      a: "https://example.com"
+    },
+    {
+      a: "jsr:@scope/test"
+    },
+    {
+      a: "npm:@scope/test"
+    },
+    {
+      a: "file:///test/path"
+    },
+    {
+      a: "data:application/test,null"
+    },
+    {
+      a: "test_invalid_url",
+      b: Error
+    }
+  ],
+  date: [
+    {
+      a: new Date("2024-01-01T00:00:00.000Z")
+    },
+    {
+      a: "test_invalid_date",
+      b: Error
+    }
+  ],
+  error: [
+    {
+      a: new Error("Test error")
+    },
+    {
+      a: `${new Error("Test error")}`,
+      b: Error
+    }
+  ],
+  expression: [
+    {
+      a: "${foo + 1}"
+    },
+    {
+      a: "foo + 1",
+      b: Error
+    }
+  ],
+  callable: [
+    {
+      a: ()=>{}
+    },
+    {
+      a: async ()=>{}
+    },
+    {
+      a: null,
+      b: Error
+    },
+    {
+      a: {},
+      b: Error
+    }
+  ],
+  parser: [
+    {
+      a: Object.assign(is.object({
+        foo: is.string()
+      }), {
+        [Symbol.for("Deno.customInspect")]: ()=>"schema"
+      })
+    },
+    {
+      a: {
+        parse: ()=>({})
+      }
+    }
+  ],
+  unknown: [
+    {
+      a: null
+    },
+    {
+      a: 123
+    },
+    {
+      a: "string"
+    },
+    {
+      a: true
+    },
+    {
+      a: []
+    },
+    {
+      a: {}
+    },
+    {
+      a: {
+        foo: "bar"
+      }
+    }
+  ],
+  meta (meta) {
+    return [
+      {
+        a: pick(meta, [
+          "url",
+          "dirname",
+          "filename"
+        ])
+      },
+      {
+        a: {},
+        b: Error
+      }
+    ];
+  },
+  enum (values) {
+    return [
+      ...values.map((a)=>({
+          a
+        })),
+      {
+        a: "TEST_INVALID_ENUM_VALUE",
+        b: Error
+      }
+    ];
+  },
+  default (b, options) {
+    return [
+      {
+        a: undefined,
+        b,
+        ...options
+      }
+    ];
+  }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/is/testing/spec.ts"],"sourcesContent":["// Imports\nimport type { testing } from \"@libs/testing\"\nimport { is } from \"../is.js\"\nimport { pick } from \"@std/collections\"\nimport { expect } from \"@libs/testing\"\nimport { inspect } from \"@libs/testing/highlight\"\n\n/** Test case definition. */\nexport type testcase = { a: unknown; b?: unknown; env?: Record<string, string> }\n\n/** Configuration options for {@linkcode spec()}. */\nexport type SpecOptions = {\n  /** Whether to perform a prefault check. */\n  prefault?: boolean\n  /** Whether to perform a strictness check. */\n  strict?: boolean\n  /** Setup function to run before tests. */\n  setup?: () => void\n}\n\n/** Specification check helper. */\nexport const spec = Object.assign(function (name: string, schema: is.ZodType, testsuites: Array<testcase> | Record<PropertyKey, Array<testcase>>, { prefault = true, strict = true, setup }: SpecOptions = {}): void {\n  if (Array.isArray(testsuites))\n    testsuites = { \"*\": testsuites }\n  // Prefault check\n  if (prefault)\n    Deno.test(`\\`${name}.parse()\\` has prefault`, () => expect(schema.parse(undefined)).toMatchObject({}))\n  // Strictness check\n  if (strict)\n    Deno.test(`\\`${name}.parse()\\` is strict`, () => expect(() => schema.parse({ __strictness_test__: true })).toThrow())\n  // Parsing checks\n  for (const [key, testcases] of Object.entries(testsuites)) {\n    for (const testcase of testcases) {\n      const a = key === \"*\" ? testcase.a : { [key]: testcase.a }\n      const b = \"b\" in testcase ? testcase.b : testcase.a\n      Deno.test(`\\`${name}.parse(${inspect(a)})\\` ${b === Error ? \"throws error\" : `is parsed${\"b\" in testcase ? ` as \\`${inspect(b)}\\`` : \"\"}`}${\"env\" in testcase ? ` with \\`${inspect(testcase.env)}\\`` : \"\"}`, { permissions: { env: testcase.env ? true : false } }, () => {\n        const env = {} as NonNullable<testcase[\"env\"]>\n        try {\n          setup?.()\n\n          // Apply environment variables\n          if (testcase.env) {\n            for (const [key, value] of Object.entries(testcase.env)) {\n              if (Deno.env.has(key))\n                env[key] = Deno.env.get(key)!\n              Deno.env.set(key, value)\n            }\n          }\n          // Apply test\n          if (b === Error)\n            expect(() => schema.parse(a)).toThrow()\n          else {\n            if ((key === \"*\") && ((typeof b !== \"object\") || (b === null))) {\n              expect(schema.parse(a)).toEqual(b as Record<PropertyKey, unknown>)\n              return\n            }\n            if ((b instanceof Date) || (b === \"2024-01-01T00:00:00.000Z\")) {\n              const da = schema.parse(a) as Date\n              expect((key === \"*\" ? da : (da as testing)[key]).getTime()).toBe(new Date(b).getTime())\n              return\n            }\n            expect(schema.parse(a)).toMatchObject(key === \"*\" ? b as Record<PropertyKey, unknown> : { [key]: b })\n          }\n        } finally {\n          for (const [key, value] of Object.entries(env))\n            Deno.env.set(key, value)\n        }\n      })\n    }\n  }\n}, {\n  optional: [\n    { a: undefined, b: undefined },\n  ],\n  nullable: [\n    { a: null },\n  ],\n  primitive: [\n    { a: \"foo\" },\n    { a: 123 },\n    { a: 123n },\n    { a: true },\n    { a: undefined },\n    { a: null },\n    { a: new Date(\"2024-01-01T00:00:00.000Z\") },\n    { a: new Error(\"Testing\") },\n    { a: Symbol.for(\"@@testing\"), b: Error },\n    { a: {}, b: Error },\n    { a: [], b: Error },\n    { a: function () {}, b: Error },\n  ],\n  boolean: [\n    { a: true },\n    { a: false },\n  ],\n  string: Object.assign([\n    { a: \"foo\" },\n  ], {\n    arrayable: [\n      { a: \"a\", b: [\"a\"] },\n      { a: [\"a\", \"b\"], b: [\"a\", \"b\"] },\n    ],\n  }),\n  positive: {\n    int: [\n      { a: 1 },\n      { a: \"1\", b: 1 },\n      { a: -1, b: Error },\n      { a: \"-1\", b: Error },\n      { a: \"NaN\", b: Error },\n    ],\n    finite: [\n      { a: 1 },\n      { a: NaN, b: Error },\n      { a: Infinity, b: Error },\n    ],\n    infinity: [\n      { a: Infinity },\n      { a: \"Infinity\", b: Infinity },\n    ],\n  },\n  record: Object.assign([\n    { a: { foo: \"bar\", baz: 123 }, b: { foo: \"bar\", baz: 123 } },\n    { a: \"foo\", b: Error },\n  ], {\n    primitive: [\n      { a: { foo: \"bar\" } },\n      { a: { foo: 123 } },\n      { a: { foo: 123n } },\n      { a: { foo: true } },\n      { a: { foo: undefined } },\n      { a: { foo: null } },\n      { a: { foo: Symbol.for(\"@@testing\") }, b: Error },\n      { a: { foo: {} }, b: Error },\n      { a: { foo: [] }, b: Error },\n      { a: { foo: function () {} }, b: Error },\n    ],\n  }),\n  array: {\n    unique: [\n      { a: [\"a\", \"b\", \"b\", \"a\", \"c\"], b: [\"a\", \"b\", \"c\"] },\n    ],\n    typed: [\n      { a: new Int8Array() },\n      { a: new Uint8Array() },\n      { a: new Uint8ClampedArray() },\n      { a: new Int16Array() },\n      { a: new Uint16Array() },\n      { a: new Int32Array() },\n      { a: new Uint32Array() },\n      { a: new Float16Array() },\n      { a: new Float32Array() },\n      { a: new Float64Array() },\n      { a: new BigInt64Array() },\n      { a: new BigUint64Array() },\n    ],\n  },\n  response: {\n    body: {\n      init: [\n        { a: null },\n        { a: \"foo\" },\n        { a: new Blob() },\n        { a: new ArrayBuffer(8) },\n        { a: new DataView(new ArrayBuffer(8)) },\n        { a: new FormData() },\n        { a: new ReadableStream() },\n        { a: new URLSearchParams() },\n        { a: new Int8Array() },\n      ],\n    },\n  },\n  ulid: [\n    { a: \"0\".repeat(26) },\n    { a: \"TEST_INVALID_ULID\", b: Error },\n  ],\n  url: [\n    { a: \"http://example.com\" },\n    { a: \"https://example.com\" },\n    { a: \"jsr:@scope/test\" },\n    { a: \"npm:@scope/test\" },\n    { a: \"file:///test/path\" },\n    { a: \"data:application/test,null\" },\n    { a: \"test_invalid_url\", b: Error },\n  ],\n  date: [\n    { a: new Date(\"2024-01-01T00:00:00.000Z\") },\n    { a: \"test_invalid_date\", b: Error },\n  ],\n  error: [\n    { a: new Error(\"Test error\") },\n    { a: `${new Error(\"Test error\")}`, b: Error },\n  ],\n  expression: [\n    { a: \"${foo + 1}\" },\n    { a: \"foo + 1\", b: Error },\n  ],\n  callable: [\n    { a: () => {} },\n    { a: async () => {} },\n    { a: null, b: Error },\n    { a: {}, b: Error },\n  ],\n  parser: [\n    { a: Object.assign(is.object({ foo: is.string() }), { [Symbol.for(\"Deno.customInspect\")]: () => \"schema\" }) },\n    { a: { parse: () => ({}) } },\n  ],\n  unknown: [\n    { a: null },\n    { a: 123 },\n    { a: \"string\" },\n    { a: true },\n    { a: [] },\n    { a: {} },\n    { a: { foo: \"bar\" } },\n  ],\n  meta(meta: ImportMeta) {\n    return [\n      { a: pick(meta, [\"url\", \"dirname\", \"filename\"]) },\n      { a: {}, b: Error },\n    ]\n  },\n  enum(values: readonly string[]) {\n    return [\n      ...values.map((a) => ({ a })),\n      { a: \"TEST_INVALID_ENUM_VALUE\", b: Error },\n    ]\n  },\n  default(b: unknown, options?: Omit<testcase, \"a\" | \"b\">) {\n    return [\n      { a: undefined, b, ...options },\n    ]\n  },\n}) as ((name: string, schema: is.ZodType, testsuites: Array<testcase> | Record<PropertyKey, Array<testcase>>, options?: SpecOptions) => void) & {\n  optional: Array<testcase>\n  nullable: Array<testcase>\n  primitive: Array<testcase>\n  boolean: Array<testcase>\n  string: {\n    arrayable: Array<testcase>\n  } & Array<testcase>\n  positive: {\n    int: Array<testcase>\n    finite: Array<testcase>\n    infinity: Array<testcase>\n  }\n  record: {\n    primitive: Array<testcase>\n  } & Array<testcase>\n  array: {\n    unique: Array<testcase>\n    typed: Array<testcase>\n  }\n  response: {\n    body: {\n      init: Array<testcase>\n    }\n  }\n  ulid: Array<testcase>\n  url: Array<testcase>\n  date: Array<testcase>\n  error: Array<testcase>\n  expression: Array<testcase>\n  callable: Array<testcase>\n  parser: Array<testcase>\n  unknown: Array<testcase>\n  meta: (meta: ImportMeta) => Array<testcase>\n  enum: (values: readonly string[]) => Array<testcase>\n  default: (b: unknown, options?: Omit<testcase, \"a\" | \"b\">) => Array<testcase>\n}\n"],"names":[],"mappings":"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"}