@nxgt/graphql-validation 0.0.0-stage → 0.1.0

package/dist/chunks/index-n3hypgpf.js

@@ -0,0 +1,315 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/constraint-directive.ts
+import { DirectiveLocation } from "graphql";
+
+// src/rules/all.ts
+var exports_all2 = {};
+__export(exports_all2, {
+  containsRule: () => containsRule,
+  endsWithRule: () => endsWithRule,
+  exclusiveMaxRule: () => exclusiveMaxRule,
+  exclusiveMinRule: () => exclusiveMinRule,
+  formatRule: () => formatRule,
+  maxItemsRule: () => maxItemsRule,
+  maxLengthRule: () => maxLengthRule,
+  maxRule: () => maxRule,
+  minItemsRule: () => minItemsRule,
+  minLengthRule: () => minLengthRule,
+  minRule: () => minRule,
+  multipleOfRule: () => multipleOfRule,
+  notContainsRule: () => notContainsRule,
+  patternRule: () => patternRule,
+  startsWithRule: () => startsWithRule
+});
+
+// src/rules/rule.ts
+function defineRule(rule) {
+  return rule;
+}
+var literal = (value) => JSON.stringify(value);
+
+// src/rules/contains.ts
+var containsRule = defineRule({
+  argument: "contains",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.includes(value),
+  toCode: (schema, value) => `${schema}.includes(${literal(value)})`,
+  owns: (issue) => issue.format === "includes"
+});
+// src/rules/ends-with.ts
+var endsWithRule = defineRule({
+  argument: "endsWith",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.endsWith(value),
+  toCode: (schema, value) => `${schema}.endsWith(${literal(value)})`,
+  owns: (issue) => issue.format === "ends_with"
+});
+// src/rules/exclusive-max.ts
+var exclusiveMaxRule = defineRule({
+  argument: "exclusiveMax",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.lt(value),
+  toCode: (schema, value) => `${schema}.lt(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "number" && issue.inclusive === false
+});
+// src/rules/exclusive-min.ts
+var exclusiveMinRule = defineRule({
+  argument: "exclusiveMin",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.gt(value),
+  toCode: (schema, value) => `${schema}.gt(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "number" && issue.inclusive === false
+});
+// src/formats/all.ts
+var exports_all = {};
+__export(exports_all, {
+  byteFormat: () => byteFormat,
+  dateFormat: () => dateFormat,
+  dateTimeFormat: () => dateTimeFormat,
+  emailFormat: () => emailFormat,
+  ipv4Format: () => ipv4Format,
+  ipv6Format: () => ipv6Format,
+  uriFormat: () => uriFormat,
+  uuidFormat: () => uuidFormat
+});
+
+// src/formats/byte.ts
+import { z } from "zod";
+
+// src/formats/format.ts
+function defineFormat(format) {
+  return format;
+}
+
+// src/formats/byte.ts
+var byteFormat = defineFormat({
+  name: "byte",
+  toZod: () => z.base64(),
+  toCode: () => "z.base64()"
+});
+// src/formats/date.ts
+import { z as z2 } from "zod";
+var dateFormat = defineFormat({
+  name: "date",
+  toZod: () => z2.iso.date(),
+  toCode: () => "z.iso.date()"
+});
+// src/formats/date-time.ts
+import { z as z3 } from "zod";
+var dateTimeFormat = defineFormat({
+  name: "date-time",
+  toZod: () => z3.iso.datetime({ offset: true }),
+  toCode: () => "z.iso.datetime({ offset: true })"
+});
+// src/formats/email.ts
+import { z as z4 } from "zod";
+var emailFormat = defineFormat({
+  name: "email",
+  toZod: () => z4.email(),
+  toCode: () => "z.email()"
+});
+// src/formats/ipv4.ts
+import { z as z5 } from "zod";
+var ipv4Format = defineFormat({
+  name: "ipv4",
+  toZod: () => z5.ipv4(),
+  toCode: () => "z.ipv4()"
+});
+// src/formats/ipv6.ts
+import { z as z6 } from "zod";
+var ipv6Format = defineFormat({
+  name: "ipv6",
+  toZod: () => z6.ipv6(),
+  toCode: () => "z.ipv6()"
+});
+// src/formats/uri.ts
+import { z as z7 } from "zod";
+var uriFormat = defineFormat({
+  name: "uri",
+  toZod: () => z7.url({ protocol: /^(https?|ftp)$/ }),
+  toCode: () => "z.url({ protocol: /^(https?|ftp)$/ })"
+});
+// src/formats/uuid.ts
+import { z as z8 } from "zod";
+var uuidFormat = defineFormat({
+  name: "uuid",
+  toZod: () => z8.uuid(),
+  toCode: () => "z.uuid()"
+});
+// src/formats/index.ts
+var formats = Object.fromEntries(Object.values(exports_all).map((format) => [format.name, format]));
+function formatNamed(name) {
+  if (Object.hasOwn(formats, name))
+    return formats[name];
+  throw new Error(`Unknown @constraint format "${name}". Known formats: ${Object.keys(formats).join(", ")}.`);
+}
+
+// src/rules/format.ts
+var NARROWING = new Set(["starts_with", "ends_with", "includes", "regex"]);
+var formatRule = defineRule({
+  argument: "format",
+  type: "String",
+  target: "string",
+  base: true,
+  toZod: (_schema, value) => formatNamed(value).toZod(),
+  toCode: (_schema, value) => formatNamed(value).toCode(),
+  owns: (issue) => issue.code === "invalid_format" && !NARROWING.has(issue.format ?? "")
+});
+// src/rules/max.ts
+var maxRule = defineRule({
+  argument: "max",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.lte(value),
+  toCode: (schema, value) => `${schema}.lte(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "number" && issue.inclusive === true
+});
+// src/rules/max-items.ts
+var maxItemsRule = defineRule({
+  argument: "maxItems",
+  type: "Int",
+  target: "list",
+  toZod: (schema, value) => schema.max(value),
+  toCode: (schema, value) => `${schema}.max(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "array"
+});
+// src/rules/max-length.ts
+var maxLengthRule = defineRule({
+  argument: "maxLength",
+  type: "Int",
+  target: "string",
+  toZod: (schema, value) => schema.max(value),
+  toCode: (schema, value) => `${schema}.max(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "string"
+});
+// src/rules/min.ts
+var minRule = defineRule({
+  argument: "min",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.gte(value),
+  toCode: (schema, value) => `${schema}.gte(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "number" && issue.inclusive === true
+});
+// src/rules/min-items.ts
+var minItemsRule = defineRule({
+  argument: "minItems",
+  type: "Int",
+  target: "list",
+  toZod: (schema, value) => schema.min(value),
+  toCode: (schema, value) => `${schema}.min(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "array"
+});
+// src/rules/min-length.ts
+var minLengthRule = defineRule({
+  argument: "minLength",
+  type: "Int",
+  target: "string",
+  toZod: (schema, value) => schema.min(value),
+  toCode: (schema, value) => `${schema}.min(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "string"
+});
+// src/rules/multiple-of.ts
+var multipleOfRule = defineRule({
+  argument: "multipleOf",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.multipleOf(value),
+  toCode: (schema, value) => `${schema}.multipleOf(${value})`,
+  owns: (issue) => issue.code === "not_multiple_of"
+});
+// src/rules/not-contains.ts
+var message = (value) => `Must not contain ${literal(value)}`;
+var notContainsRule = defineRule({
+  argument: "notContains",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.refine((input) => !input.includes(value), message(value)),
+  toCode: (schema, value) => `${schema}.refine((input) => !input.includes(${literal(value)}), ${literal(message(value))})`,
+  owns: (issue) => issue.code === "custom"
+});
+// src/rules/pattern.ts
+function compile(value) {
+  try {
+    return new RegExp(value);
+  } catch (error) {
+    throw new Error(`Invalid @constraint pattern ${literal(value)}: ${error.message}`);
+  }
+}
+var patternRule = defineRule({
+  argument: "pattern",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.regex(compile(value)),
+  toCode: (schema, value) => `${schema}.regex(new RegExp(${literal(compile(value).source)}))`,
+  owns: (issue) => issue.format === "regex"
+});
+// src/rules/starts-with.ts
+var startsWithRule = defineRule({
+  argument: "startsWith",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.startsWith(value),
+  toCode: (schema, value) => `${schema}.startsWith(${literal(value)})`,
+  owns: (issue) => issue.format === "starts_with"
+});
+// src/rules/index.ts
+var rules = Object.fromEntries(Object.values(exports_all2).map((rule) => [rule.argument, rule]));
+function applyRule(rule, schema, value) {
+  const toZod = rule.toZod;
+  return toZod(schema, value);
+}
+function constraintOf(issue) {
+  const fields = issue;
+  return Object.values(rules).find((rule) => rule.owns(fields))?.argument;
+}
+
+// src/constraint-directive.ts
+var constraintTypeDefs2 = `directive @constraint(
+${Object.values(rules).map((rule) => `	${rule.argument}: ${rule.type}`).join(`
+`)}
+) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+`;
+var allowed = new Set([
+  DirectiveLocation.ARGUMENT_DEFINITION,
+  DirectiveLocation.INPUT_FIELD_DEFINITION
+]);
+function assertOwnConstraint(directive) {
+  const problems = [
+    ...directive.isRepeatable ? ["repeatable, and only its first use is read"] : [],
+    ...directive.locations.filter((location) => !allowed.has(location)).map((location) => `allowed on ${location}`),
+    ...directive.args.flatMap((arg) => {
+      const rule = rules[arg.name];
+      if (!rule)
+        return [`declares ${arg.name}, which no rule reads`];
+      const type = String(arg.type);
+      return type === rule.type ? [] : [`declares ${arg.name}: ${type}, not ${rule.type}`];
+    })
+  ];
+  if (problems.length > 0) {
+    throw new Error(`This schema's @constraint is not constraintTypeDefs': it is ${problems.join("; ")}. Declare it with constraintTypeDefs.`);
+  }
+}
+
+export { rules, applyRule, constraintOf, constraintTypeDefs2, assertOwnConstraint };
+
+//# debugId=4D959B1CB64DEA2664756E2164756E21
+//# sourceMappingURL=index-n3hypgpf.js.map

package/dist/chunks/index-n3hypgpf.js.map

@@ -0,0 +1,37 @@
+{
+  "version": 3,
+  "sources": ["../src/constraint-directive.ts", "../src/rules/rule.ts", "../src/rules/contains.ts", "../src/rules/ends-with.ts", "../src/rules/exclusive-max.ts", "../src/rules/exclusive-min.ts", "../src/formats/byte.ts", "../src/formats/format.ts", "../src/formats/date.ts", "../src/formats/date-time.ts", "../src/formats/email.ts", "../src/formats/ipv4.ts", "../src/formats/ipv6.ts", "../src/formats/uri.ts", "../src/formats/uuid.ts", "../src/formats/index.ts", "../src/rules/format.ts", "../src/rules/max.ts", "../src/rules/max-items.ts", "../src/rules/max-length.ts", "../src/rules/min.ts", "../src/rules/min-items.ts", "../src/rules/min-length.ts", "../src/rules/multiple-of.ts", "../src/rules/not-contains.ts", "../src/rules/pattern.ts", "../src/rules/starts-with.ts", "../src/rules/index.ts"],
+  "sourcesContent": [
+    "import { DirectiveLocation, type GraphQLDirective } from 'graphql';\nimport { rules } from './rules';\n\n/**\n * The SDL of `@constraint`, to add to a schema-first server's `typeDefs`,\n * written from the rules: an argument is declared once its rule exists.\n *\n * Its arguments are graphql-constraint-directive's, minus `uniqueTypeName`\n * (a detail of that package's scalar wrapping). It is allowed on arguments\n * and input fields only, where that package also allows output fields: a\n * resolver's result is the output scalars' job, and a directive that checked\n * nothing there would be a promise broken in silence.\n */\nexport const constraintTypeDefs: string = `directive @constraint(\n${Object.values(rules)\n\t.map((rule) => `\\t${rule.argument}: ${rule.type}`)\n\t.join('\\n')}\n) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION\n`;\n\nconst allowed = new Set<string>([\n\tDirectiveLocation.ARGUMENT_DEFINITION,\n\tDirectiveLocation.INPUT_FIELD_DEFINITION,\n]);\n\n/**\n * Fails when the schema's `@constraint` is not the one\n * {@link constraintTypeDefs} declares — graphql-constraint-directive's, say,\n * kept from a migration. Its extra locations would be accepted and checked\n * by nothing, its extra arguments mean nothing here, and an argument of\n * another type would reach a rule as the wrong kind of value.\n */\nexport function assertOwnConstraint(directive: GraphQLDirective): void {\n\tconst problems = [\n\t\t...(directive.isRepeatable\n\t\t\t? ['repeatable, and only its first use is read']\n\t\t\t: []),\n\t\t...directive.locations\n\t\t\t.filter((location) => !allowed.has(location))\n\t\t\t.map((location) => `allowed on ${location}`),\n\t\t...directive.args.flatMap((arg) => {\n\t\t\tconst rule = (rules as Record<string, { type: string } | undefined>)[\n\t\t\t\targ.name\n\t\t\t];\n\t\t\tif (!rule) return [`declares ${arg.name}, which no rule reads`];\n\t\t\tconst type = String(arg.type);\n\t\t\treturn type === rule.type\n\t\t\t\t? []\n\t\t\t\t: [`declares ${arg.name}: ${type}, not ${rule.type}`];\n\t\t}),\n\t];\n\tif (problems.length > 0) {\n\t\tthrow new Error(\n\t\t\t`This schema's @constraint is not constraintTypeDefs': it is ${problems.join('; ')}. Declare it with constraintTypeDefs.`,\n\t\t);\n\t}\n}\n",
+    "import type { z } from 'zod';\nimport type { StringSchema } from '../formats/format';\n\n/** The schema each kind of rule narrows. */\nexport interface Targets {\n\tstring: StringSchema;\n\tnumber: z.ZodNumber;\n\tlist: z.ZodArray<z.ZodType>;\n}\n\nexport type Target = keyof Targets;\n\n/** What a `@constraint` argument's value can be. */\ninterface ValueOf {\n\tInt: number;\n\tFloat: number;\n\tString: string;\n}\n\n/**\n * One `@constraint` argument: its GraphQL type in the directive's SDL, the\n * kind of value it narrows, and the same narrowing twice — `toZod` applied to\n * a schema at startup, `toCode` written as source by a code generator. The\n * spec beside each rule proves the two accept and refuse the same values.\n *\n * A `base` rule (only `format`) replaces the schema instead of narrowing it,\n * so a builder applies it before every other rule of its target.\n */\nexport interface Rule<\n\tA extends string = string,\n\tT extends keyof ValueOf = keyof ValueOf,\n\tK extends Target = Target,\n> {\n\treadonly argument: A;\n\treadonly type: T;\n\treadonly target: K;\n\treadonly base?: true;\n\treadonly toZod: (schema: Targets[K], value: ValueOf[T]) => Targets[K];\n\t/**\n\t * `schema` is the source of the schema this rule narrows. The source names\n\t * zod as a free `z`: the generated file imports it.\n\t */\n\treadonly toCode: (schema: string, value: ValueOf[T]) => string;\n\t/**\n\t * Whether a Zod issue is this rule's refusal, so the error a client gets\n\t * names the rule (`constraint: 'minLength'`), which does not change with\n\t * Zod's own issue codes.\n\t */\n\treadonly owns: (issue: IssueFields) => boolean;\n}\n\n/** The fields of a Zod issue a rule recognises its refusal by. */\nexport interface IssueFields {\n\treadonly code: string;\n\treadonly origin?: string;\n\treadonly format?: string;\n\treadonly inclusive?: boolean;\n}\n\n/** Declares a rule, with its argument name kept literal. */\nexport function defineRule<\n\tconst A extends string,\n\tT extends keyof ValueOf,\n\tK extends Target,\n>(rule: Rule<A, T, K>): Rule<A, T, K> {\n\treturn rule;\n}\n\n/** A string literal as source: quotes and escapes included. */\nexport const literal = (value: string): string => JSON.stringify(value);\n",
+    "import { defineRule, literal } from './rule';\n\nexport const containsRule = defineRule({\n\targument: 'contains',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.includes(value),\n\ttoCode: (schema, value) => `${schema}.includes(${literal(value)})`,\n\towns: (issue) => issue.format === 'includes',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const endsWithRule = defineRule({\n\targument: 'endsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.endsWith(value),\n\ttoCode: (schema, value) => `${schema}.endsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'ends_with',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMaxRule = defineRule({\n\targument: 'exclusiveMax',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lt(value),\n\ttoCode: (schema, value) => `${schema}.lt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMinRule = defineRule({\n\targument: 'exclusiveMin',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gt(value),\n\ttoCode: (schema, value) => `${schema}.gt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const byteFormat = defineFormat({\n\tname: 'byte',\n\ttoZod: () => z.base64(),\n\ttoCode: () => 'z.base64()',\n});\n",
+    "import type { z } from 'zod';\n\n/** A string schema, plain or a format (`z.email()` is not a `z.ZodString`). */\nexport type StringSchema = z.ZodString | z.ZodStringFormat;\n\n/**\n * One value of `@constraint(format: \"...\")`: the schema it stands for, as a\n * schema at startup and as source for a code generator.\n */\nexport interface Format<N extends string = string> {\n\treadonly name: N;\n\treadonly toZod: () => StringSchema;\n\treadonly toCode: () => string;\n}\n\n/** Declares a format, with its name kept literal. */\nexport function defineFormat<const N extends string>(\n\tformat: Format<N>,\n): Format<N> {\n\treturn format;\n}\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const dateFormat = defineFormat({\n\tname: 'date',\n\ttoZod: () => z.iso.date(),\n\ttoCode: () => 'z.iso.date()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\n// RFC 3339 with an offset, in its canonical spelling only: an uppercase `T`\n// and `Z`, seconds present. graphql-constraint-directive (validator's\n// isRFC3339) also takes a lowercase `t`, `z` or a space.\nexport const dateTimeFormat = defineFormat({\n\tname: 'date-time',\n\ttoZod: () => z.iso.datetime({ offset: true }),\n\ttoCode: () => 'z.iso.datetime({ offset: true })',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const emailFormat = defineFormat({\n\tname: 'email',\n\ttoZod: () => z.email(),\n\ttoCode: () => 'z.email()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const ipv4Format = defineFormat({\n\tname: 'ipv4',\n\ttoZod: () => z.ipv4(),\n\ttoCode: () => 'z.ipv4()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const ipv6Format = defineFormat({\n\tname: 'ipv6',\n\ttoZod: () => z.ipv6(),\n\ttoCode: () => 'z.ipv6()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\n// graphql-constraint-directive's `uri` is validator's isURL: http, https or\n// ftp. The scheme is required here, where isURL lets `example.com` through,\n// and nothing else gets in: no `javascript:`, no `mailto:`.\nexport const uriFormat = defineFormat({\n\tname: 'uri',\n\ttoZod: () => z.url({ protocol: /^(https?|ftp)$/ }),\n\ttoCode: () => 'z.url({ protocol: /^(https?|ftp)$/ })',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const uuidFormat = defineFormat({\n\tname: 'uuid',\n\ttoZod: () => z.uuid(),\n\ttoCode: () => 'z.uuid()',\n});\n",
+    "import * as all from './all';\nimport type { Format } from './format';\n\n/**\n * Every format, keyed by the value `@constraint(format: \"...\")` takes.\n * Derived from what `./all` exports, so a new format is one file and one\n * line there.\n */\nexport const formats = Object.fromEntries(\n\tObject.values(all).map((format) => [format.name, format]),\n) as { readonly [N in FormatName]: Format<N> };\n\n/** A value `@constraint(format: \"...\")` takes. */\nexport type FormatName = (typeof all)[keyof typeof all]['name'];\n\n/** The format named `name`, or an error that lists the known ones. */\nexport function formatNamed(name: string): Format {\n\tif (Object.hasOwn(formats, name)) return formats[name as FormatName];\n\tthrow new Error(\n\t\t`Unknown @constraint format \"${name}\". Known formats: ${Object.keys(formats).join(', ')}.`,\n\t);\n}\n",
+    "import { formatNamed } from '../formats';\nimport { defineRule } from './rule';\n\n// The string rules' own formats; every other invalid_format is a format's.\nconst NARROWING = new Set(['starts_with', 'ends_with', 'includes', 'regex']);\n\nexport const formatRule = defineRule({\n\targument: 'format',\n\ttype: 'String',\n\ttarget: 'string',\n\tbase: true,\n\ttoZod: (_schema, value) => formatNamed(value).toZod(),\n\ttoCode: (_schema, value) => formatNamed(value).toCode(),\n\towns: (issue) =>\n\t\tissue.code === 'invalid_format' && !NARROWING.has(issue.format ?? ''),\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxRule = defineRule({\n\targument: 'max',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lte(value),\n\ttoCode: (schema, value) => `${schema}.lte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxItemsRule = defineRule({\n\targument: 'maxItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxLengthRule = defineRule({\n\targument: 'maxLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minRule = defineRule({\n\targument: 'min',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gte(value),\n\ttoCode: (schema, value) => `${schema}.gte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minItemsRule = defineRule({\n\targument: 'minItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minLengthRule = defineRule({\n\targument: 'minLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const multipleOfRule = defineRule({\n\targument: 'multipleOf',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.multipleOf(value),\n\ttoCode: (schema, value) => `${schema}.multipleOf(${value})`,\n\towns: (issue) => issue.code === 'not_multiple_of',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nconst message = (value: string) => `Must not contain ${literal(value)}`;\n\nexport const notContainsRule = defineRule({\n\targument: 'notContains',\n\ttype: 'String',\n\ttarget: 'string',\n\t// `refine` keeps the schema's own type, so later rules still chain.\n\ttoZod: (schema, value) =>\n\t\tschema.refine((input) => !input.includes(value), message(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.refine((input) => !input.includes(${literal(value)}), ${literal(message(value))})`,\n\towns: (issue) => issue.code === 'custom',\n});\n",
+    "import { defineRule, literal } from './rule';\n\n/** The pattern as a RegExp, or an error that names the argument. */\nfunction compile(value: string): RegExp {\n\ttry {\n\t\treturn new RegExp(value);\n\t} catch (error) {\n\t\tthrow new Error(\n\t\t\t`Invalid @constraint pattern ${literal(value)}: ${(error as Error).message}`,\n\t\t);\n\t}\n}\n\nexport const patternRule = defineRule({\n\targument: 'pattern',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.regex(compile(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.regex(new RegExp(${literal(compile(value).source)}))`,\n\towns: (issue) => issue.format === 'regex',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const startsWithRule = defineRule({\n\targument: 'startsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.startsWith(value),\n\ttoCode: (schema, value) => `${schema}.startsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'starts_with',\n});\n",
+    "import type { z } from 'zod';\nimport * as all from './all';\nimport type { IssueFields } from './rule';\n\n/**\n * One of the rules, as its own type: a builder narrows it on `target`, so a\n * number schema never reaches a string rule.\n */\nexport type RegisteredRule = (typeof all)[keyof typeof all];\n\n/** An argument `@constraint` takes. */\nexport type ConstraintArgument = RegisteredRule['argument'];\n\n/**\n * Every rule, keyed by its `@constraint` argument. Derived from what\n * `./all` exports, so a new rule is one file and one line there, and the\n * directive's SDL follows.\n */\nexport const rules = Object.fromEntries(\n\tObject.values(all).map((rule) => [rule.argument, rule]),\n) as {\n\treadonly [A in ConstraintArgument]: Extract<RegisteredRule, { argument: A }>;\n};\n\n/**\n * Applies a rule to a schema its caller has already matched to the rule's\n * target: the one place the rule's typed `toZod` meets a schema built from\n * GraphQL types, which the compiler cannot relate.\n */\nexport function applyRule(\n\trule: RegisteredRule,\n\tschema: z.ZodType,\n\tvalue: string | number,\n): z.ZodType {\n\tconst toZod = rule.toZod as unknown as (\n\t\tschema: z.ZodType,\n\t\tvalue: string | number,\n\t) => z.ZodType;\n\treturn toZod(schema, value);\n}\n\n/** The `@constraint` argument whose rule refused with this issue, if any. */\nexport function constraintOf(\n\tissue: z.core.$ZodIssue,\n): ConstraintArgument | undefined {\n\tconst fields = issue as unknown as IssueFields;\n\treturn Object.values(rules).find((rule) => rule.owns(fields))?.argument;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "4D959B1CB64DEA2664756E2164756E21",
+  "names": []
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  constraintTypeDefs2
+} from "./chunks/index-n3hypgpf.js";
+
+// src/typedefs-command.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+var DEFAULT_OUT = "generated/graphql/constraint.graphqls";
+var usage = `Usage: nxgt-graphql-validation typedefs [--out [<file>]]
+
+  typedefs           print the SDL of @constraint
+  --out [<file>]     write it to <file> instead, creating its folder
+                     (default: ${DEFAULT_OUT})
+  --help, -h         show this help
+`;
+function graphqls() {
+  return `# The @constraint directive of @nxgt/graphql-validation, for your IDE.
+# Generated by \`nxgt-graphql-validation typedefs\`: do not edit.
+
+${constraintTypeDefs2}`;
+}
+function refuse(message) {
+  process.stderr.write(`${message}
+
+${usage}`);
+  return 2;
+}
+async function main(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(usage);
+    return 0;
+  }
+  const [command, ...rest] = argv;
+  if (command === undefined)
+    return refuse("No command.");
+  if (command !== "typedefs")
+    return refuse(`Unknown command "${command}".`);
+  if (rest.length === 0) {
+    process.stdout.write(graphqls());
+    return 0;
+  }
+  const [flag, file, ...extra] = rest;
+  if (flag !== "--out" || extra.length > 0 || file === "" || file?.startsWith("-")) {
+    return refuse(`Unexpected arguments: ${rest.join(" ")}`);
+  }
+  const out = file ?? DEFAULT_OUT;
+  try {
+    await mkdir(dirname(out), { recursive: true });
+    await writeFile(out, graphqls());
+  } catch (error) {
+    process.stderr.write(`typedefs failed: ${error.message}
+`);
+    return 1;
+  }
+  process.stdout.write(`Wrote ${out}
+`);
+  return 0;
+}
+
+// src/cli.ts
+process.stdout.on("error", (error) => {
+  if (error.code !== "EPIPE")
+    throw error;
+});
+process.exitCode = await main(process.argv.slice(2));
+
+//# debugId=675FAE0D80D1DEF264756E2164756E21
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/typedefs-command.ts", "../src/cli.ts"],
+  "sourcesContent": [
+    "// The `typedefs` command of the bin, apart from `cli.ts` so a spec can run\n// it without spawning a process. Its flags read as `nxgt-graphql-scalars\n// typedefs`' do, so both bins are used the same way.\nimport { mkdir, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { constraintTypeDefs } from './constraint-directive';\n\n/** Where `--out` writes when it is given no file. */\nexport const DEFAULT_OUT = 'generated/graphql/constraint.graphqls';\n\nconst usage = `Usage: nxgt-graphql-validation typedefs [--out [<file>]]\n\n  typedefs           print the SDL of @constraint\n  --out [<file>]     write it to <file> instead, creating its folder\n                     (default: ${DEFAULT_OUT})\n  --help, -h         show this help\n`;\n\n/** The `.graphqls` file's content: a header, then the SDL. */\nexport function graphqls(): string {\n\treturn `# The @constraint directive of @nxgt/graphql-validation, for your IDE.\\n# Generated by \\`nxgt-graphql-validation typedefs\\`: do not edit.\\n\\n${constraintTypeDefs}`;\n}\n\nfunction refuse(message: string): number {\n\tprocess.stderr.write(`${message}\\n\\n${usage}`);\n\treturn 2;\n}\n\n/**\n * Runs the bin on `argv`: 0 done, 1 the file could not be written, 2 a usage\n * error (nxgt-mongo-backup's convention). `--help` anywhere wins.\n */\nexport async function main(argv: readonly string[]): Promise<number> {\n\tif (argv.includes('--help') || argv.includes('-h')) {\n\t\tprocess.stdout.write(usage);\n\t\treturn 0;\n\t}\n\tconst [command, ...rest] = argv;\n\tif (command === undefined) return refuse('No command.');\n\tif (command !== 'typedefs') return refuse(`Unknown command \"${command}\".`);\n\tif (rest.length === 0) {\n\t\tprocess.stdout.write(graphqls());\n\t\treturn 0;\n\t}\n\tconst [flag, file, ...extra] = rest;\n\tif (\n\t\tflag !== '--out' ||\n\t\textra.length > 0 ||\n\t\tfile === '' ||\n\t\tfile?.startsWith('-')\n\t) {\n\t\treturn refuse(`Unexpected arguments: ${rest.join(' ')}`);\n\t}\n\tconst out = file ?? DEFAULT_OUT;\n\ttry {\n\t\tawait mkdir(dirname(out), { recursive: true });\n\t\tawait writeFile(out, graphqls());\n\t} catch (error) {\n\t\tprocess.stderr.write(`typedefs failed: ${(error as Error).message}\\n`);\n\t\treturn 1;\n\t}\n\tprocess.stdout.write(`Wrote ${out}\\n`);\n\treturn 0;\n}\n",
+    "#!/usr/bin/env node\n/**\n * The `nxgt-graphql-validation` bin. One command, `typedefs`: the SDL of\n * `@constraint` — what `constraintTypeDefs` holds — on standard output or\n * into a file, so an IDE's GraphQL plugin knows the directive without a\n * running server. It reads nothing and writes only the file it is given.\n */\nimport { main } from './typedefs-command';\n\n// A reader that closed the pipe (`| head`) wants no more: not an error.\nprocess.stdout.on('error', (error: NodeJS.ErrnoException) => {\n\tif (error.code !== 'EPIPE') throw error;\n});\n\nprocess.exitCode = await main(process.argv.slice(2));\n"
+  ],
+  "mappings": ";;;;;;AAGA;AACA;AAIO,IAAM,cAAc;AAE3B,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA,iCAImB;AAAA;AAAA;AAK1B,SAAS,QAAQ,GAAW;AAAA,EAClC,OAAO;AAAA;AAAA;AAAA,EAAgJ;AAAA;AAGxJ,SAAS,MAAM,CAAC,SAAyB;AAAA,EACxC,QAAQ,OAAO,MAAM,GAAG;AAAA;AAAA,EAAc,OAAO;AAAA,EAC7C,OAAO;AAAA;AAOR,eAAsB,IAAI,CAAC,MAA0C;AAAA,EACpE,IAAI,KAAK,SAAS,QAAQ,KAAK,KAAK,SAAS,IAAI,GAAG;AAAA,IACnD,QAAQ,OAAO,MAAM,KAAK;AAAA,IAC1B,OAAO;AAAA,EACR;AAAA,EACA,OAAO,YAAY,QAAQ;AAAA,EAC3B,IAAI,YAAY;AAAA,IAAW,OAAO,OAAO,aAAa;AAAA,EACtD,IAAI,YAAY;AAAA,IAAY,OAAO,OAAO,oBAAoB,WAAW;AAAA,EACzE,IAAI,KAAK,WAAW,GAAG;AAAA,IACtB,QAAQ,OAAO,MAAM,SAAS,CAAC;AAAA,IAC/B,OAAO;AAAA,EACR;AAAA,EACA,OAAO,MAAM,SAAS,SAAS;AAAA,EAC/B,IACC,SAAS,WACT,MAAM,SAAS,KACf,SAAS,MACT,MAAM,WAAW,GAAG,GACnB;AAAA,IACD,OAAO,OAAO,yBAAyB,KAAK,KAAK,GAAG,GAAG;AAAA,EACxD;AAAA,EACA,MAAM,MAAM,QAAQ;AAAA,EACpB,IAAI;AAAA,IACH,MAAM,MAAM,QAAQ,GAAG,GAAG,EAAE,WAAW,KAAK,CAAC;AAAA,IAC7C,MAAM,UAAU,KAAK,SAAS,CAAC;AAAA,IAC9B,OAAO,OAAO;AAAA,IACf,QAAQ,OAAO,MAAM,oBAAqB,MAAgB;AAAA,CAAW;AAAA,IACrE,OAAO;AAAA;AAAA,EAER,QAAQ,OAAO,MAAM,SAAS;AAAA,CAAO;AAAA,EACrC,OAAO;AAAA;;;ACpDR,QAAQ,OAAO,GAAG,SAAS,CAAC,UAAiC;AAAA,EAC5D,IAAI,MAAM,SAAS;AAAA,IAAS,MAAM;AAAA,CAClC;AAED,QAAQ,WAAW,MAAM,KAAK,QAAQ,KAAK,MAAM,CAAC,CAAC;",
+  "debugId": "675FAE0D80D1DEF264756E2164756E21",
+  "names": []
+}

package/dist/constraint-directive.d.ts

@@ -0,0 +1,21 @@
+import { type GraphQLDirective } from 'graphql';
+/**
+ * The SDL of `@constraint`, to add to a schema-first server's `typeDefs`,
+ * written from the rules: an argument is declared once its rule exists.
+ *
+ * Its arguments are graphql-constraint-directive's, minus `uniqueTypeName`
+ * (a detail of that package's scalar wrapping). It is allowed on arguments
+ * and input fields only, where that package also allows output fields: a
+ * resolver's result is the output scalars' job, and a directive that checked
+ * nothing there would be a promise broken in silence.
+ */
+export declare const constraintTypeDefs: string;
+/**
+ * Fails when the schema's `@constraint` is not the one
+ * {@link constraintTypeDefs} declares — graphql-constraint-directive's, say,
+ * kept from a migration. Its extra locations would be accepted and checked
+ * by nothing, its extra arguments mean nothing here, and an argument of
+ * another type would reach a rule as the wrong kind of value.
+ */
+export declare function assertOwnConstraint(directive: GraphQLDirective): void;
+//# sourceMappingURL=constraint-directive.d.ts.map

package/dist/constraint-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-directive.d.ts","sourceRoot":"","sources":["../src/constraint-directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGnE;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAKhC,CAAC;AAOF;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAwBrE"}

package/dist/formats/all.d.ts

@@ -0,0 +1,9 @@
+export * from './byte';
+export * from './date';
+export * from './date-time';
+export * from './email';
+export * from './ipv4';
+export * from './ipv6';
+export * from './uri';
+export * from './uuid';
+//# sourceMappingURL=all.d.ts.map

package/dist/formats/all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../src/formats/all.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC"}

package/dist/formats/byte.d.ts

@@ -0,0 +1,2 @@
+export declare const byteFormat: import("./format").Format<"byte">;
+//# sourceMappingURL=byte.d.ts.map

package/dist/formats/byte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte.d.ts","sourceRoot":"","sources":["../../src/formats/byte.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}

package/dist/formats/date-time.d.ts

@@ -0,0 +1,2 @@
+export declare const dateTimeFormat: import("./format").Format<"date-time">;
+//# sourceMappingURL=date-time.d.ts.map

package/dist/formats/date-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-time.d.ts","sourceRoot":"","sources":["../../src/formats/date-time.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,wCAIzB,CAAC"}

package/dist/formats/date.d.ts

@@ -0,0 +1,2 @@
+export declare const dateFormat: import("./format").Format<"date">;
+//# sourceMappingURL=date.d.ts.map

package/dist/formats/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/formats/date.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}

package/dist/formats/email.d.ts

@@ -0,0 +1,2 @@
+export declare const emailFormat: import("./format").Format<"email">;
+//# sourceMappingURL=email.d.ts.map

package/dist/formats/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../src/formats/email.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,oCAItB,CAAC"}

package/dist/formats/format.d.ts

@@ -0,0 +1,15 @@
+import type { z } from 'zod';
+/** A string schema, plain or a format (`z.email()` is not a `z.ZodString`). */
+export type StringSchema = z.ZodString | z.ZodStringFormat;
+/**
+ * One value of `@constraint(format: "...")`: the schema it stands for, as a
+ * schema at startup and as source for a code generator.
+ */
+export interface Format<N extends string = string> {
+    readonly name: N;
+    readonly toZod: () => StringSchema;
+    readonly toCode: () => string;
+}
+/** Declares a format, with its name kept literal. */
+export declare function defineFormat<const N extends string>(format: Format<N>): Format<N>;
+//# sourceMappingURL=format.d.ts.map

package/dist/formats/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/formats/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,eAAe,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAChD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,MAAM,YAAY,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;CAC9B;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAClD,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GACf,MAAM,CAAC,CAAC,CAAC,CAEX"}

package/dist/formats/index.d.ts

@@ -0,0 +1,13 @@
+import * as all from './all';
+import type { Format } from './format';
+/**
+ * Every format, keyed by the value `@constraint(format: "...")` takes.
+ * Derived from what `./all` exports, so a new format is one file and one
+ * line there.
+ */
+export declare const formats: { readonly [N in FormatName]: Format<N>; };
+/** A value `@constraint(format: "...")` takes. */
+export type FormatName = (typeof all)[keyof typeof all]['name'];
+/** The format named `name`, or an error that lists the known ones. */
+export declare function formatNamed(name: string): Format;
+//# sourceMappingURL=index.d.ts.map

package/dist/formats/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAEf,EAAE,QAAQ,EAAE,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,GAAE,CAAC;AAE/C,kDAAkD;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKhD"}

package/dist/formats/ipv4.d.ts

@@ -0,0 +1,2 @@
+export declare const ipv4Format: import("./format").Format<"ipv4">;
+//# sourceMappingURL=ipv4.d.ts.map

package/dist/formats/ipv4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipv4.d.ts","sourceRoot":"","sources":["../../src/formats/ipv4.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}

package/dist/formats/ipv6.d.ts

@@ -0,0 +1,2 @@
+export declare const ipv6Format: import("./format").Format<"ipv6">;
+//# sourceMappingURL=ipv6.d.ts.map

package/dist/formats/ipv6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipv6.d.ts","sourceRoot":"","sources":["../../src/formats/ipv6.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}

package/dist/formats/uri.d.ts

@@ -0,0 +1,2 @@
+export declare const uriFormat: import("./format").Format<"uri">;
+//# sourceMappingURL=uri.d.ts.map

package/dist/formats/uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../../src/formats/uri.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS,kCAIpB,CAAC"}

package/dist/formats/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare const uuidFormat: import("./format").Format<"uuid">;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/formats/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../src/formats/uuid.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}