@pyreon/validation 0.3.0 → 0.7.0

package/lib/analysis/index.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"95cef231-1","name":"utils.ts"},{"uid":"95cef231-3","name":"zod.ts"},{"uid":"95cef231-5","name":"valibot.ts"},{"uid":"95cef231-7","name":"arktype.ts"},{"uid":"95cef231-9","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"95cef231-1":{"renderedLength":452,"gzipLength":302,"brotliLength":0,"metaUid":"95cef231-0"},"95cef231-3":{"renderedLength":1636,"gzipLength":620,"brotliLength":0,"metaUid":"95cef231-2"},"95cef231-5":{"renderedLength":1879,"gzipLength":695,"brotliLength":0,"metaUid":"95cef231-4"},"95cef231-7":{"renderedLength":1677,"gzipLength":643,"brotliLength":0,"metaUid":"95cef231-6"},"95cef231-9":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"95cef231-8"}},"nodeMetas":{"95cef231-0":{"id":"/src/utils.ts","moduleParts":{"index.js":"95cef231-1"},"imported":[],"importedBy":[{"uid":"95cef231-8"},{"uid":"95cef231-2"},{"uid":"95cef231-4"},{"uid":"95cef231-6"}]},"95cef231-2":{"id":"/src/zod.ts","moduleParts":{"index.js":"95cef231-3"},"imported":[{"uid":"95cef231-0"}],"importedBy":[{"uid":"95cef231-8"}]},"95cef231-4":{"id":"/src/valibot.ts","moduleParts":{"index.js":"95cef231-5"},"imported":[{"uid":"95cef231-0"}],"importedBy":[{"uid":"95cef231-8"}]},"95cef231-6":{"id":"/src/arktype.ts","moduleParts":{"index.js":"95cef231-7"},"imported":[{"uid":"95cef231-0"}],"importedBy":[{"uid":"95cef231-8"}]},"95cef231-8":{"id":"/src/index.ts","moduleParts":{"index.js":"95cef231-9"},"imported":[{"uid":"95cef231-2"},{"uid":"95cef231-4"},{"uid":"95cef231-6"},{"uid":"95cef231-0"}],"importedBy":[],"isEntry":true}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"99584f89-1","name":"utils.ts"},{"uid":"99584f89-3","name":"arktype.ts"},{"uid":"99584f89-5","name":"valibot.ts"},{"uid":"99584f89-7","name":"zod.ts"},{"uid":"99584f89-9","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"99584f89-1":{"renderedLength":452,"gzipLength":302,"brotliLength":0,"metaUid":"99584f89-0"},"99584f89-3":{"renderedLength":1677,"gzipLength":643,"brotliLength":0,"metaUid":"99584f89-2"},"99584f89-5":{"renderedLength":1879,"gzipLength":695,"brotliLength":0,"metaUid":"99584f89-4"},"99584f89-7":{"renderedLength":1636,"gzipLength":620,"brotliLength":0,"metaUid":"99584f89-6"},"99584f89-9":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"99584f89-8"}},"nodeMetas":{"99584f89-0":{"id":"/src/utils.ts","moduleParts":{"index.js":"99584f89-1"},"imported":[],"importedBy":[{"uid":"99584f89-8"},{"uid":"99584f89-2"},{"uid":"99584f89-4"},{"uid":"99584f89-6"}]},"99584f89-2":{"id":"/src/arktype.ts","moduleParts":{"index.js":"99584f89-3"},"imported":[{"uid":"99584f89-0"}],"importedBy":[{"uid":"99584f89-8"}]},"99584f89-4":{"id":"/src/valibot.ts","moduleParts":{"index.js":"99584f89-5"},"imported":[{"uid":"99584f89-0"}],"importedBy":[{"uid":"99584f89-8"}]},"99584f89-6":{"id":"/src/zod.ts","moduleParts":{"index.js":"99584f89-7"},"imported":[{"uid":"99584f89-0"}],"importedBy":[{"uid":"99584f89-8"}]},"99584f89-8":{"id":"/src/index.ts","moduleParts":{"index.js":"99584f89-9"},"imported":[{"uid":"99584f89-2"},{"uid":"99584f89-0"},{"uid":"99584f89-4"},{"uid":"99584f89-6"}],"importedBy":[],"isEntry":true}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/arktype.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ninterface ArkTypeCallable {\n  (data: unknown): unknown\n}\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACST,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CACtB,QAAO,EAAE;AACX,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACOT,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CACtB,QAAO,EAAE;AACX,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/lib/index.js

@@ -14,65 +14,69 @@ function issuesToRecord(issues) {
 }
 
 //#endregion
-//#region src/zod.ts
-function zodIssuesToGeneric(issues) {
-	return issues.map((issue) => ({
-		path: issue.path.map(String).join("."),
-		message: issue.message
+//#region src/arktype.ts
+function isArkErrors(result) {
+	return Array.isArray(result) && "summary" in result;
+}
+function arkIssuesToGeneric(errors) {
+	return errors.map((err) => ({
+		path: err.path.map(String).join("."),
+		message: err.message
 	}));
 }
 /**
-* Create a form-level schema validator from a Zod schema.
-* Supports both sync and async Zod schemas (uses `safeParseAsync`).
+* Create a form-level schema validator from an ArkType schema.
+*
+* Accepts any callable ArkType `Type` instance. The schema is duck-typed —
+* no ArkType import required.
 *
 * @example
-* import { z } from 'zod'
-* import { zodSchema } from '@pyreon/validation/zod'
+* import { type } from 'arktype'
+* import { arktypeSchema } from '@pyreon/validation/arktype'
 *
-* const schema = z.object({
-*   email: z.string().email(),
-*   password: z.string().min(8),
+* const schema = type({
+*   email: 'string.email',
+*   password: 'string >= 8',
 * })
 *
 * const form = useForm({
 *   initialValues: { email: '', password: '' },
-*   schema: zodSchema(schema),
+*   schema: arktypeSchema(schema),
 *   onSubmit: (values) => { ... },
 * })
 */
-function zodSchema(schema) {
-	return async (values) => {
+function arktypeSchema(schema) {
+	return (values) => {
 		try {
-			const result = await schema.safeParseAsync(values);
-			if (result.success) return {};
-			return issuesToRecord(zodIssuesToGeneric(result.error.issues));
+			const result = schema(values);
+			if (!isArkErrors(result)) return {};
+			return issuesToRecord(arkIssuesToGeneric(result));
 		} catch (err) {
 			return { "": err instanceof Error ? err.message : String(err) };
 		}
 	};
 }
 /**
-* Create a single-field validator from a Zod schema.
-* Supports both sync and async Zod refinements.
+* Create a single-field validator from an ArkType schema.
 *
 * @example
-* import { z } from 'zod'
-* import { zodField } from '@pyreon/validation/zod'
+* import { type } from 'arktype'
+* import { arktypeField } from '@pyreon/validation/arktype'
 *
 * const form = useForm({
 *   initialValues: { email: '' },
 *   validators: {
-*     email: zodField(z.string().email('Invalid email')),
+*     email: arktypeField(type('string.email')),
 *   },
 *   onSubmit: (values) => { ... },
 * })
 */
-function zodField(schema) {
-	return async (value) => {
+function arktypeField(schema) {
+	return (value) => {
 		try {
-			const result = await schema.safeParseAsync(value);
-			if (result.success) return void 0;
-			return result.error.issues[0]?.message;
+			const result = schema(value);
+			if (!isArkErrors(result)) return void 0;
+			return result[0]?.message;
 		} catch (err) {
 			return err instanceof Error ? err.message : String(err);
 		}
@@ -149,69 +153,65 @@ function valibotField(schema, safeParseFn) {
 }
 
 //#endregion
-//#region src/arktype.ts
-function isArkErrors(result) {
-	return Array.isArray(result) && "summary" in result;
-}
-function arkIssuesToGeneric(errors) {
-	return errors.map((err) => ({
-		path: err.path.map(String).join("."),
-		message: err.message
+//#region src/zod.ts
+function zodIssuesToGeneric(issues) {
+	return issues.map((issue) => ({
+		path: issue.path.map(String).join("."),
+		message: issue.message
 	}));
 }
 /**
-* Create a form-level schema validator from an ArkType schema.
-*
-* Accepts any callable ArkType `Type` instance. The schema is duck-typed —
-* no ArkType import required.
+* Create a form-level schema validator from a Zod schema.
+* Supports both sync and async Zod schemas (uses `safeParseAsync`).
 *
 * @example
-* import { type } from 'arktype'
-* import { arktypeSchema } from '@pyreon/validation/arktype'
+* import { z } from 'zod'
+* import { zodSchema } from '@pyreon/validation/zod'
 *
-* const schema = type({
-*   email: 'string.email',
-*   password: 'string >= 8',
+* const schema = z.object({
+*   email: z.string().email(),
+*   password: z.string().min(8),
 * })
 *
 * const form = useForm({
 *   initialValues: { email: '', password: '' },
-*   schema: arktypeSchema(schema),
+*   schema: zodSchema(schema),
 *   onSubmit: (values) => { ... },
 * })
 */
-function arktypeSchema(schema) {
-	return (values) => {
+function zodSchema(schema) {
+	return async (values) => {
 		try {
-			const result = schema(values);
-			if (!isArkErrors(result)) return {};
-			return issuesToRecord(arkIssuesToGeneric(result));
+			const result = await schema.safeParseAsync(values);
+			if (result.success) return {};
+			return issuesToRecord(zodIssuesToGeneric(result.error.issues));
 		} catch (err) {
 			return { "": err instanceof Error ? err.message : String(err) };
 		}
 	};
 }
 /**
-* Create a single-field validator from an ArkType schema.
+* Create a single-field validator from a Zod schema.
+* Supports both sync and async Zod refinements.
 *
 * @example
-* import { type } from 'arktype'
-* import { arktypeField } from '@pyreon/validation/arktype'
+* import { z } from 'zod'
+* import { zodField } from '@pyreon/validation/zod'
 *
 * const form = useForm({
 *   initialValues: { email: '' },
 *   validators: {
-*     email: arktypeField(type('string.email')),
+*     email: zodField(z.string().email('Invalid email')),
 *   },
 *   onSubmit: (values) => { ... },
 * })
 */
-function arktypeField(schema) {
-	return (value) => {
+function zodField(schema) {
+	return async (value) => {
 		try {
-			const result = schema(value);
-			if (!isArkErrors(result)) return void 0;
-			return result[0]?.message;
+			const result = await schema.safeParseAsync(value);
+			if (result.success) return void 0;
+			return result.error.issues[0]?.message;
 		} catch (err) {
 			return err instanceof Error ? err.message : String(err);
 		}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/zod.ts","../src/valibot.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(\n        valibotIssuesToGeneric(result.issues ?? []),\n      )\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ninterface ArkTypeCallable {\n  (data: unknown): unknown\n}\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(\n        valibotIssuesToGeneric(result.issues ?? []),\n      )\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/types/arktype.d.ts

@@ -1,90 +1,49 @@
-//#region src/utils.ts
-/**
-* Convert an array of validation issues into a flat field → error record.
-* For nested paths like ["address", "city"], produces "address.city".
-* When multiple issues exist for the same path, the first message wins.
-*/
-function issuesToRecord(issues) {
-  const errors = {};
-  for (const issue of issues) {
-    const key = issue.path;
-    if (errors[key] === void 0) errors[key] = issue.message;
-  }
-  return errors;
-}
+import { SchemaValidateFn, ValidateFn } from "@pyreon/form";
 
-//#endregion
-//#region src/arktype.ts
-function isArkErrors(result) {
-  return Array.isArray(result) && "summary" in result;
-}
-function arkIssuesToGeneric(errors) {
-  return errors.map(err => ({
-    path: err.path.map(String).join("."),
-    message: err.message
-  }));
-}
+//#region src/arktype.d.ts
 /**
-* Create a form-level schema validator from an ArkType schema.
-*
-* Accepts any callable ArkType `Type` instance. The schema is duck-typed —
-* no ArkType import required.
-*
-* @example
-* import { type } from 'arktype'
-* import { arktypeSchema } from '@pyreon/validation/arktype'
-*
-* const schema = type({
-*   email: 'string.email',
-*   password: 'string >= 8',
-* })
-*
-* const form = useForm({
-*   initialValues: { email: '', password: '' },
-*   schema: arktypeSchema(schema),
-*   onSubmit: (values) => { ... },
-* })
-*/
-function arktypeSchema(schema) {
-  return values => {
-    try {
-      const result = schema(values);
-      if (!isArkErrors(result)) return {};
-      return issuesToRecord(arkIssuesToGeneric(result));
-    } catch (err) {
-      return {
-        "": err instanceof Error ? err.message : String(err)
-      };
-    }
-  };
-}
+ * Internal callable interface matching ArkType's Type.
+ * Not exposed publicly — consumers pass their ArkType schema directly.
+ */
+type ArkTypeCallable = (data: unknown) => unknown;
 /**
-* Create a single-field validator from an ArkType schema.
-*
-* @example
-* import { type } from 'arktype'
-* import { arktypeField } from '@pyreon/validation/arktype'
-*
-* const form = useForm({
-*   initialValues: { email: '' },
-*   validators: {
-*     email: arktypeField(type('string.email')),
-*   },
-*   onSubmit: (values) => { ... },
-* })
-*/
-function arktypeField(schema) {
-  return value => {
-    try {
-      const result = schema(value);
-      if (!isArkErrors(result)) return void 0;
-      return result[0]?.message;
-    } catch (err) {
-      return err instanceof Error ? err.message : String(err);
-    }
-  };
-}
-
+ * Create a form-level schema validator from an ArkType schema.
+ *
+ * Accepts any callable ArkType `Type` instance. The schema is duck-typed —
+ * no ArkType import required.
+ *
+ * @example
+ * import { type } from 'arktype'
+ * import { arktypeSchema } from '@pyreon/validation/arktype'
+ *
+ * const schema = type({
+ *   email: 'string.email',
+ *   password: 'string >= 8',
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: arktypeSchema(schema),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function arktypeSchema<TValues extends Record<string, unknown>>(schema: ArkTypeCallable): SchemaValidateFn<TValues>;
+/**
+ * Create a single-field validator from an ArkType schema.
+ *
+ * @example
+ * import { type } from 'arktype'
+ * import { arktypeField } from '@pyreon/validation/arktype'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: arktypeField(type('string.email')),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T>;
 //#endregion
 export { arktypeField, arktypeSchema };
-//# sourceMappingURL=arktype.d.ts.map
+//# sourceMappingURL=arktype2.d.ts.map

package/lib/types/arktype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.d.ts","names":[],"sources":["../../src/utils.ts","../../src/arktype.ts"],"mappings":";;;;;;AAQA,SAAgB,cAAA,CACd,MAAA,EACiD;EACjD,MAAM,MAAA,GAAS,CAAA,CAAE;EACjB,KAAK,MAAM,KAAA,IAAS,MAAA,EAAQ;IAC1B,MAAM,GAAA,GAAM,KAAA,CAAM,IAAA;IAElB,IAAI,MAAA,CAAO,GAAA,CAAA,KAAS,KAAA,CAAA,EAClB,MAAA,CAAO,GAAA,CAAA,GAAO,KAAA,CAAM,OAAA;;EAGxB,OAAO,MAAA;;;;;ACST,SAAS,WAAA,CAAY,MAAA,EAAsC;EACzD,OAAO,KAAA,CAAM,OAAA,CAAQ,MAAA,CAAO,IAAI,SAAA,IAAc,MAAA;;AAGhD,SAAS,kBAAA,CAAmB,MAAA,EAAsC;EAChE,OAAO,MAAA,CAAO,GAAA,CAAK,GAAA,KAAS;IAC1B,IAAA,EAAM,GAAA,CAAI,IAAA,CAAK,GAAA,CAAI,MAAA,CAAO,CAAC,IAAA,CAAK,GAAA,CAAI;IACpC,OAAA,EAAS,GAAA,CAAI;GACd,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,aAAA,CACd,MAAA,EAC2B;EAC3B,OAAQ,MAAA,IAAoB;IAC1B,IAAI;MACF,MAAM,MAAA,GAAS,MAAA,CAAO,MAAA,CAAO;MAC7B,IAAI,CAAC,WAAA,CAAY,MAAA,CAAO,EACtB,OAAO,CAAA,CAAE;MACX,OAAO,cAAA,CAAwB,kBAAA,CAAmB,MAAA,CAAO,CAAC;aACnD,GAAA,EAAK;MACZ,OAAO;QACL,EAAA,EAAI,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA;MAAI,CACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,YAAA,CAAgB,MAAA,EAAwC;EACtE,OAAQ,KAAA,IAAa;IACnB,IAAI;MACF,MAAM,MAAA,GAAS,MAAA,CAAO,KAAA,CAAM;MAC5B,IAAI,CAAC,WAAA,CAAY,MAAA,CAAO,EAAE,OAAO,KAAA,CAAA;MACjC,OAAO,MAAA,CAAO,CAAA,CAAA,EAAI,OAAA;aACX,GAAA,EAAK;MACZ,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI"}
+{"version":3,"file":"arktype2.d.ts","names":[],"sources":["../../../src/arktype.ts"],"mappings":";;;;;AAIqB;;KAoBhB,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AAgCA;;iBAhCgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,UAAA,CAAW,CAAA"}