@vertz/schema 0.0.2

package/dist/index.js

@@ -0,0 +1,2438 @@
+// src/core/errors.ts
+var ErrorCode;
+((ErrorCode2) => {
+  ErrorCode2["InvalidType"] = "invalid_type";
+  ErrorCode2["TooSmall"] = "too_small";
+  ErrorCode2["TooBig"] = "too_big";
+  ErrorCode2["InvalidString"] = "invalid_string";
+  ErrorCode2["InvalidEnumValue"] = "invalid_enum_value";
+  ErrorCode2["InvalidLiteral"] = "invalid_literal";
+  ErrorCode2["InvalidUnion"] = "invalid_union";
+  ErrorCode2["InvalidDate"] = "invalid_date";
+  ErrorCode2["MissingProperty"] = "missing_property";
+  ErrorCode2["UnrecognizedKeys"] = "unrecognized_keys";
+  ErrorCode2["Custom"] = "custom";
+  ErrorCode2["InvalidIntersection"] = "invalid_intersection";
+  ErrorCode2["NotMultipleOf"] = "not_multiple_of";
+  ErrorCode2["NotFinite"] = "not_finite";
+})(ErrorCode ||= {});
+
+class ParseError extends Error {
+  issues;
+  constructor(issues) {
+    const message = ParseError.formatMessage(issues);
+    super(message);
+    this.name = "ParseError";
+    this.issues = issues;
+  }
+  static formatMessage(issues) {
+    return issues.map((issue) => {
+      const path = issue.path.length > 0 ? ` at "${issue.path.join(".")}"` : "";
+      return `${issue.message}${path}`;
+    }).join("; ");
+  }
+}
+// src/core/parse-context.ts
+class ParseContext {
+  issues = [];
+  _path = [];
+  addIssue(issue) {
+    this.issues.push({
+      ...issue,
+      path: issue.path ?? [...this._path]
+    });
+  }
+  hasIssues() {
+    return this.issues.length > 0;
+  }
+  pushPath(segment) {
+    this._path.push(segment);
+  }
+  popPath() {
+    this._path.pop();
+  }
+  get path() {
+    return [...this._path];
+  }
+}
+// src/core/registry.ts
+class SchemaRegistry {
+  static _schemas = new Map;
+  static register(name, schema) {
+    SchemaRegistry._schemas.set(name, schema);
+  }
+  static get(name) {
+    return SchemaRegistry._schemas.get(name);
+  }
+  static getOrThrow(name) {
+    const schema = SchemaRegistry._schemas.get(name);
+    if (!schema) {
+      throw new Error(`Schema "${name}" not found in registry`);
+    }
+    return schema;
+  }
+  static has(name) {
+    return SchemaRegistry._schemas.has(name);
+  }
+  static getAll() {
+    return SchemaRegistry._schemas;
+  }
+  static clear() {
+    SchemaRegistry._schemas.clear();
+  }
+}
+// src/introspection/json-schema.ts
+class RefTracker {
+  _seen = new Set;
+  _defs = {};
+  hasSeen(id) {
+    return this._seen.has(id);
+  }
+  markSeen(id) {
+    this._seen.add(id);
+  }
+  addDef(id, schema) {
+    this._defs[id] = schema;
+  }
+  getDefs() {
+    return { ...this._defs };
+  }
+}
+function toJSONSchema(schema) {
+  return schema.toJSONSchema();
+}
+
+// src/core/schema.ts
+class Schema {
+  _id;
+  _description;
+  _meta;
+  _examples;
+  constructor() {
+    this._examples = [];
+  }
+  parse(value) {
+    const ctx = new ParseContext;
+    const result = this._runPipeline(value, ctx);
+    if (ctx.hasIssues()) {
+      throw new ParseError(ctx.issues);
+    }
+    return result;
+  }
+  safeParse(value) {
+    const ctx = new ParseContext;
+    try {
+      const data = this._runPipeline(value, ctx);
+      if (ctx.hasIssues()) {
+        return { success: false, error: new ParseError(ctx.issues) };
+      }
+      return { success: true, data };
+    } catch (e) {
+      if (e instanceof ParseError) {
+        return { success: false, error: e };
+      }
+      throw e;
+    }
+  }
+  id(name) {
+    const clone = this._clone();
+    clone._id = name;
+    SchemaRegistry.register(name, clone);
+    return clone;
+  }
+  describe(description) {
+    const clone = this._clone();
+    clone._description = description;
+    return clone;
+  }
+  meta(data) {
+    const clone = this._clone();
+    clone._meta = { ...this._meta ?? {}, ...data };
+    return clone;
+  }
+  example(value) {
+    const clone = this._clone();
+    clone._examples = [...this._examples, value];
+    return clone;
+  }
+  get metadata() {
+    return {
+      type: this._schemaType(),
+      id: this._id,
+      description: this._description,
+      meta: this._meta,
+      examples: this._examples
+    };
+  }
+  toJSONSchema() {
+    const tracker = new RefTracker;
+    const schema = this._toJSONSchemaWithRefs(tracker);
+    const defs = tracker.getDefs();
+    if (Object.keys(defs).length > 0) {
+      return { $defs: defs, ...schema };
+    }
+    return schema;
+  }
+  _toJSONSchemaWithRefs(tracker) {
+    if (this._id && tracker.hasSeen(this._id)) {
+      return { $ref: `#/$defs/${this._id}` };
+    }
+    if (this._id) {
+      tracker.markSeen(this._id);
+      const jsonSchema = this._applyMetadata(this._toJSONSchema(tracker));
+      tracker.addDef(this._id, jsonSchema);
+      return { $ref: `#/$defs/${this._id}` };
+    }
+    return this._applyMetadata(this._toJSONSchema(tracker));
+  }
+  _applyMetadata(schema) {
+    if (this._description)
+      schema.description = this._description;
+    if (this._examples.length > 0)
+      schema.examples = this._examples;
+    return schema;
+  }
+  _cloneBase(target) {
+    target._id = this._id;
+    target._description = this._description;
+    target._meta = this._meta ? { ...this._meta } : undefined;
+    target._examples = [...this._examples];
+    return target;
+  }
+  optional() {
+    return new OptionalSchema(this);
+  }
+  nullable() {
+    return new NullableSchema(this);
+  }
+  default(defaultValue) {
+    return new DefaultSchema(this, defaultValue);
+  }
+  refine(predicate, params) {
+    return new RefinedSchema(this, predicate, params);
+  }
+  superRefine(refinement) {
+    return new SuperRefinedSchema(this, refinement);
+  }
+  check(refinement) {
+    return new SuperRefinedSchema(this, refinement);
+  }
+  transform(fn) {
+    return new TransformSchema(this, fn);
+  }
+  pipe(schema) {
+    return new PipeSchema(this, schema);
+  }
+  catch(fallback) {
+    return new CatchSchema(this, fallback);
+  }
+  brand() {
+    return new BrandedSchema(this);
+  }
+  readonly() {
+    return new ReadonlySchema(this);
+  }
+  _runPipeline(value, ctx) {
+    return this._parse(value, ctx);
+  }
+}
+
+class OptionalSchema extends Schema {
+  _inner;
+  constructor(_inner) {
+    super();
+    this._inner = _inner;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _parse(value, ctx) {
+    if (value === undefined)
+      return;
+    return this._inner._runPipeline(value, ctx);
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new OptionalSchema(this._inner));
+  }
+  unwrap() {
+    return this._inner;
+  }
+}
+
+class NullableSchema extends Schema {
+  _inner;
+  constructor(_inner) {
+    super();
+    this._inner = _inner;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _parse(value, ctx) {
+    if (value === null)
+      return null;
+    return this._inner._runPipeline(value, ctx);
+  }
+  _toJSONSchema(tracker) {
+    const inner = this._inner._toJSONSchemaWithRefs(tracker);
+    if (typeof inner.type === "string") {
+      return { ...inner, type: [inner.type, "null"] };
+    }
+    return { anyOf: [inner, { type: "null" }] };
+  }
+  _clone() {
+    return this._cloneBase(new NullableSchema(this._inner));
+  }
+  unwrap() {
+    return this._inner;
+  }
+}
+
+class DefaultSchema extends Schema {
+  _inner;
+  _default;
+  constructor(_inner, _default) {
+    super();
+    this._inner = _inner;
+    this._default = _default;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _parse(value, ctx) {
+    if (value === undefined) {
+      return this._inner._runPipeline(this._resolveDefault(), ctx);
+    }
+    return this._inner._runPipeline(value, ctx);
+  }
+  _toJSONSchema(tracker) {
+    const inner = this._inner._toJSONSchemaWithRefs(tracker);
+    return { ...inner, default: this._resolveDefault() };
+  }
+  _resolveDefault() {
+    return typeof this._default === "function" ? this._default() : this._default;
+  }
+  _clone() {
+    return this._cloneBase(new DefaultSchema(this._inner, this._default));
+  }
+  unwrap() {
+    return this._inner;
+  }
+}
+
+class RefinedSchema extends Schema {
+  _inner;
+  _predicate;
+  _message;
+  _path;
+  constructor(inner, predicate, params) {
+    super();
+    this._inner = inner;
+    this._predicate = predicate;
+    const normalized = typeof params === "string" ? { message: params } : params;
+    this._message = normalized?.message ?? "Custom validation failed";
+    this._path = normalized?.path;
+  }
+  _parse(value, ctx) {
+    const result = this._inner._runPipeline(value, ctx);
+    if (ctx.hasIssues())
+      return result;
+    if (!this._predicate(result)) {
+      ctx.addIssue({
+        code: "custom" /* Custom */,
+        message: this._message,
+        path: this._path
+      });
+    }
+    return result;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new RefinedSchema(this._inner, this._predicate, {
+      message: this._message,
+      path: this._path
+    }));
+  }
+}
+
+class SuperRefinedSchema extends Schema {
+  _inner;
+  _refinement;
+  constructor(inner, refinement) {
+    super();
+    this._inner = inner;
+    this._refinement = refinement;
+  }
+  _parse(value, ctx) {
+    const result = this._inner._runPipeline(value, ctx);
+    if (ctx.hasIssues())
+      return result;
+    this._refinement(result, ctx);
+    return result;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new SuperRefinedSchema(this._inner, this._refinement));
+  }
+}
+
+class TransformSchema extends Schema {
+  _inner;
+  _transform;
+  constructor(inner, transform) {
+    super();
+    this._inner = inner;
+    this._transform = transform;
+  }
+  _parse(value, ctx) {
+    const result = this._inner._runPipeline(value, ctx);
+    if (ctx.hasIssues())
+      return result;
+    try {
+      return this._transform(result);
+    } catch (e) {
+      ctx.addIssue({
+        code: "custom" /* Custom */,
+        message: e instanceof Error ? e.message : "Transform failed"
+      });
+      return result;
+    }
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new TransformSchema(this._inner, this._transform));
+  }
+}
+
+class PipeSchema extends Schema {
+  _first;
+  _second;
+  constructor(first, second) {
+    super();
+    this._first = first;
+    this._second = second;
+  }
+  _parse(value, ctx) {
+    const intermediate = this._first._runPipeline(value, ctx);
+    if (ctx.hasIssues())
+      return intermediate;
+    return this._second._runPipeline(intermediate, ctx);
+  }
+  _schemaType() {
+    return this._second._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._first._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new PipeSchema(this._first, this._second));
+  }
+}
+
+class CatchSchema extends Schema {
+  _inner;
+  _fallback;
+  constructor(inner, fallback) {
+    super();
+    this._inner = inner;
+    this._fallback = fallback;
+  }
+  _parse(value, _ctx) {
+    const innerCtx = new ParseContext;
+    const result = this._inner._runPipeline(value, innerCtx);
+    if (innerCtx.hasIssues()) {
+      return this._resolveFallback();
+    }
+    return result;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _resolveFallback() {
+    return typeof this._fallback === "function" ? this._fallback() : this._fallback;
+  }
+  _clone() {
+    return this._cloneBase(new CatchSchema(this._inner, this._fallback));
+  }
+}
+
+class BrandedSchema extends Schema {
+  _inner;
+  constructor(inner) {
+    super();
+    this._inner = inner;
+  }
+  _parse(value, ctx) {
+    return this._inner._runPipeline(value, ctx);
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new BrandedSchema(this._inner));
+  }
+}
+
+class ReadonlySchema extends Schema {
+  _inner;
+  constructor(inner) {
+    super();
+    this._inner = inner;
+  }
+  _parse(value, ctx) {
+    const result = this._inner._runPipeline(value, ctx);
+    if (ctx.hasIssues())
+      return result;
+    if (typeof result === "object" && result !== null) {
+      return Object.freeze(result);
+    }
+    return result;
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new ReadonlySchema(this._inner));
+  }
+}
+// src/core/types.ts
+var SchemaType;
+((SchemaType2) => {
+  SchemaType2["String"] = "string";
+  SchemaType2["Number"] = "number";
+  SchemaType2["BigInt"] = "bigint";
+  SchemaType2["Boolean"] = "boolean";
+  SchemaType2["Date"] = "date";
+  SchemaType2["Symbol"] = "symbol";
+  SchemaType2["Undefined"] = "undefined";
+  SchemaType2["Null"] = "null";
+  SchemaType2["Void"] = "void";
+  SchemaType2["Any"] = "any";
+  SchemaType2["Unknown"] = "unknown";
+  SchemaType2["Never"] = "never";
+  SchemaType2["NaN"] = "nan";
+  SchemaType2["Object"] = "object";
+  SchemaType2["Array"] = "array";
+  SchemaType2["Tuple"] = "tuple";
+  SchemaType2["Enum"] = "enum";
+  SchemaType2["Union"] = "union";
+  SchemaType2["DiscriminatedUnion"] = "discriminatedUnion";
+  SchemaType2["Intersection"] = "intersection";
+  SchemaType2["Record"] = "record";
+  SchemaType2["Map"] = "map";
+  SchemaType2["Set"] = "set";
+  SchemaType2["Literal"] = "literal";
+  SchemaType2["Lazy"] = "lazy";
+  SchemaType2["Custom"] = "custom";
+  SchemaType2["InstanceOf"] = "instanceof";
+  SchemaType2["File"] = "file";
+})(SchemaType ||= {});
+// src/schemas/array.ts
+class ArraySchema extends Schema {
+  _element;
+  _min;
+  _max;
+  _length;
+  constructor(element) {
+    super();
+    this._element = element;
+  }
+  _parse(value, ctx) {
+    if (!Array.isArray(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected array, received ${typeof value}`
+      });
+      return value;
+    }
+    if (this._min !== undefined && value.length < this._min) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: `Array must contain at least ${this._min} element(s)`
+      });
+    }
+    if (this._max !== undefined && value.length > this._max) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: `Array must contain at most ${this._max} element(s)`
+      });
+    }
+    if (this._length !== undefined && value.length !== this._length) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Array must contain exactly ${this._length} element(s)`
+      });
+    }
+    const result = [];
+    for (let i = 0;i < value.length; i++) {
+      ctx.pushPath(i);
+      result.push(this._element._runPipeline(value[i], ctx));
+      ctx.popPath();
+    }
+    return result;
+  }
+  min(n) {
+    const clone = this._clone();
+    clone._min = n;
+    return clone;
+  }
+  max(n) {
+    const clone = this._clone();
+    clone._max = n;
+    return clone;
+  }
+  length(n) {
+    const clone = this._clone();
+    clone._length = n;
+    return clone;
+  }
+  _schemaType() {
+    return "array" /* Array */;
+  }
+  _toJSONSchema(tracker) {
+    const schema = {
+      type: "array",
+      items: this._element._toJSONSchemaWithRefs(tracker)
+    };
+    if (this._min !== undefined)
+      schema.minItems = this._min;
+    if (this._max !== undefined)
+      schema.maxItems = this._max;
+    if (this._length !== undefined) {
+      schema.minItems = this._length;
+      schema.maxItems = this._length;
+    }
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new ArraySchema(this._element));
+    clone._min = this._min;
+    clone._max = this._max;
+    clone._length = this._length;
+    return clone;
+  }
+}
+// src/schemas/bigint.ts
+class BigIntSchema extends Schema {
+  _parse(value, ctx) {
+    if (typeof value !== "bigint") {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected bigint, received ${typeof value}`
+      });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "bigint" /* BigInt */;
+  }
+  _toJSONSchema(_tracker) {
+    return { type: "integer", format: "int64" };
+  }
+  _clone() {
+    return this._cloneBase(new BigIntSchema);
+  }
+}
+// src/schemas/boolean.ts
+class BooleanSchema extends Schema {
+  _parse(value, ctx) {
+    if (typeof value !== "boolean") {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected boolean, received ${typeof value}`
+      });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "boolean" /* Boolean */;
+  }
+  _toJSONSchema(_tracker) {
+    return { type: "boolean" };
+  }
+  _clone() {
+    return this._cloneBase(new BooleanSchema);
+  }
+}
+// src/schemas/date.ts
+class DateSchema extends Schema {
+  _min;
+  _minMessage;
+  _max;
+  _maxMessage;
+  _parse(value, ctx) {
+    if (!(value instanceof Date)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected Date, received ${typeof value}`
+      });
+      return value;
+    }
+    if (Number.isNaN(value.getTime())) {
+      ctx.addIssue({ code: "invalid_date" /* InvalidDate */, message: "Invalid date" });
+      return value;
+    }
+    if (this._min !== undefined && value.getTime() < this._min.getTime()) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: this._minMessage ?? `Date must be after ${this._min.toISOString()}`
+      });
+    }
+    if (this._max !== undefined && value.getTime() > this._max.getTime()) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: this._maxMessage ?? `Date must be before ${this._max.toISOString()}`
+      });
+    }
+    return value;
+  }
+  min(date, message) {
+    const clone = this._clone();
+    clone._min = date;
+    clone._minMessage = message;
+    return clone;
+  }
+  max(date, message) {
+    const clone = this._clone();
+    clone._max = date;
+    clone._maxMessage = message;
+    return clone;
+  }
+  _schemaType() {
+    return "date" /* Date */;
+  }
+  _toJSONSchema(_tracker) {
+    return { type: "string", format: "date-time" };
+  }
+  _clone() {
+    const clone = this._cloneBase(new DateSchema);
+    clone._min = this._min;
+    clone._minMessage = this._minMessage;
+    clone._max = this._max;
+    clone._maxMessage = this._maxMessage;
+    return clone;
+  }
+}
+
+// src/schemas/number.ts
+class NumberSchema extends Schema {
+  _gte;
+  _gteMessage;
+  _gt;
+  _gtMessage;
+  _lte;
+  _lteMessage;
+  _lt;
+  _ltMessage;
+  _int = false;
+  _positive = false;
+  _negative = false;
+  _nonnegative = false;
+  _nonpositive = false;
+  _multipleOf;
+  _finite = false;
+  _parse(value, ctx) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected number, received ${typeof value}`
+      });
+      return value;
+    }
+    if (this._gte !== undefined && value < this._gte) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: this._gteMessage ?? `Number must be greater than or equal to ${this._gte}`
+      });
+    }
+    if (this._gt !== undefined && value <= this._gt) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: this._gtMessage ?? `Number must be greater than ${this._gt}`
+      });
+    }
+    if (this._lte !== undefined && value > this._lte) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: this._lteMessage ?? `Number must be less than or equal to ${this._lte}`
+      });
+    }
+    if (this._lt !== undefined && value >= this._lt) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: this._ltMessage ?? `Number must be less than ${this._lt}`
+      });
+    }
+    if (this._int && !Number.isInteger(value)) {
+      ctx.addIssue({ code: "invalid_type" /* InvalidType */, message: "Expected integer, received float" });
+    }
+    if (this._positive && value <= 0) {
+      ctx.addIssue({ code: "too_small" /* TooSmall */, message: "Number must be positive" });
+    }
+    if (this._negative && value >= 0) {
+      ctx.addIssue({ code: "too_big" /* TooBig */, message: "Number must be negative" });
+    }
+    if (this._nonnegative && value < 0) {
+      ctx.addIssue({ code: "too_small" /* TooSmall */, message: "Number must be nonnegative" });
+    }
+    if (this._nonpositive && value > 0) {
+      ctx.addIssue({ code: "too_big" /* TooBig */, message: "Number must be nonpositive" });
+    }
+    if (this._multipleOf !== undefined && value % this._multipleOf !== 0) {
+      ctx.addIssue({
+        code: "not_multiple_of" /* NotMultipleOf */,
+        message: `Number must be a multiple of ${this._multipleOf}`
+      });
+    }
+    if (this._finite && !Number.isFinite(value)) {
+      ctx.addIssue({ code: "not_finite" /* NotFinite */, message: "Number must be finite" });
+    }
+    return value;
+  }
+  gte(n, message) {
+    const clone = this._clone();
+    clone._gte = n;
+    clone._gteMessage = message;
+    return clone;
+  }
+  min(n, message) {
+    return this.gte(n, message);
+  }
+  gt(n, message) {
+    const clone = this._clone();
+    clone._gt = n;
+    clone._gtMessage = message;
+    return clone;
+  }
+  lte(n, message) {
+    const clone = this._clone();
+    clone._lte = n;
+    clone._lteMessage = message;
+    return clone;
+  }
+  max(n, message) {
+    return this.lte(n, message);
+  }
+  lt(n, message) {
+    const clone = this._clone();
+    clone._lt = n;
+    clone._ltMessage = message;
+    return clone;
+  }
+  int() {
+    const clone = this._clone();
+    clone._int = true;
+    return clone;
+  }
+  positive() {
+    const clone = this._clone();
+    clone._positive = true;
+    return clone;
+  }
+  negative() {
+    const clone = this._clone();
+    clone._negative = true;
+    return clone;
+  }
+  nonnegative() {
+    const clone = this._clone();
+    clone._nonnegative = true;
+    return clone;
+  }
+  nonpositive() {
+    const clone = this._clone();
+    clone._nonpositive = true;
+    return clone;
+  }
+  multipleOf(n) {
+    const clone = this._clone();
+    clone._multipleOf = n;
+    return clone;
+  }
+  step(n) {
+    return this.multipleOf(n);
+  }
+  finite() {
+    const clone = this._clone();
+    clone._finite = true;
+    return clone;
+  }
+  _schemaType() {
+    return "number" /* Number */;
+  }
+  _toJSONSchema(_tracker) {
+    const schema = { type: this._int ? "integer" : "number" };
+    if (this._gte !== undefined)
+      schema.minimum = this._gte;
+    if (this._gt !== undefined)
+      schema.exclusiveMinimum = this._gt;
+    if (this._lte !== undefined)
+      schema.maximum = this._lte;
+    if (this._lt !== undefined)
+      schema.exclusiveMaximum = this._lt;
+    if (this._multipleOf !== undefined)
+      schema.multipleOf = this._multipleOf;
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new NumberSchema);
+    clone._gte = this._gte;
+    clone._gteMessage = this._gteMessage;
+    clone._gt = this._gt;
+    clone._gtMessage = this._gtMessage;
+    clone._lte = this._lte;
+    clone._lteMessage = this._lteMessage;
+    clone._lt = this._lt;
+    clone._ltMessage = this._ltMessage;
+    clone._int = this._int;
+    clone._positive = this._positive;
+    clone._negative = this._negative;
+    clone._nonnegative = this._nonnegative;
+    clone._nonpositive = this._nonpositive;
+    clone._multipleOf = this._multipleOf;
+    clone._finite = this._finite;
+    return clone;
+  }
+}
+
+// src/schemas/string.ts
+class StringSchema extends Schema {
+  _min;
+  _minMessage;
+  _max;
+  _maxMessage;
+  _length;
+  _lengthMessage;
+  _regex;
+  _startsWith;
+  _endsWith;
+  _includes;
+  _uppercase = false;
+  _lowercase = false;
+  _trim = false;
+  _toLowerCase = false;
+  _toUpperCase = false;
+  _normalize = false;
+  _parse(value, ctx) {
+    if (typeof value !== "string") {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected string, received ${typeof value}`
+      });
+      return value;
+    }
+    let v = value;
+    if (this._trim) {
+      v = v.trim();
+    }
+    if (this._toLowerCase) {
+      v = v.toLowerCase();
+    }
+    if (this._toUpperCase) {
+      v = v.toUpperCase();
+    }
+    if (this._normalize) {
+      v = v.normalize();
+    }
+    if (this._min !== undefined && v.length < this._min) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: this._minMessage ?? `String must contain at least ${this._min} character(s)`
+      });
+    }
+    if (this._max !== undefined && v.length > this._max) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: this._maxMessage ?? `String must contain at most ${this._max} character(s)`
+      });
+    }
+    if (this._length !== undefined && v.length !== this._length) {
+      ctx.addIssue({
+        code: "invalid_string" /* InvalidString */,
+        message: this._lengthMessage ?? `String must be exactly ${this._length} character(s)`
+      });
+    }
+    if (this._regex !== undefined && !this._regex.test(v)) {
+      ctx.addIssue({
+        code: "invalid_string" /* InvalidString */,
+        message: `Invalid: must match ${this._regex}`
+      });
+    }
+    if (this._startsWith !== undefined && !v.startsWith(this._startsWith)) {
+      ctx.addIssue({
+        code: "invalid_string" /* InvalidString */,
+        message: `Invalid input: must start with "${this._startsWith}"`
+      });
+    }
+    if (this._endsWith !== undefined && !v.endsWith(this._endsWith)) {
+      ctx.addIssue({
+        code: "invalid_string" /* InvalidString */,
+        message: `Invalid input: must end with "${this._endsWith}"`
+      });
+    }
+    if (this._includes !== undefined && !v.includes(this._includes)) {
+      ctx.addIssue({
+        code: "invalid_string" /* InvalidString */,
+        message: `Invalid input: must include "${this._includes}"`
+      });
+    }
+    if (this._uppercase && v !== v.toUpperCase()) {
+      ctx.addIssue({ code: "invalid_string" /* InvalidString */, message: "Expected string to be uppercase" });
+    }
+    if (this._lowercase && v !== v.toLowerCase()) {
+      ctx.addIssue({ code: "invalid_string" /* InvalidString */, message: "Expected string to be lowercase" });
+    }
+    return v;
+  }
+  min(n, message) {
+    const clone = this._clone();
+    clone._min = n;
+    clone._minMessage = message;
+    return clone;
+  }
+  max(n, message) {
+    const clone = this._clone();
+    clone._max = n;
+    clone._maxMessage = message;
+    return clone;
+  }
+  length(n, message) {
+    const clone = this._clone();
+    clone._length = n;
+    clone._lengthMessage = message;
+    return clone;
+  }
+  regex(pattern) {
+    const clone = this._clone();
+    clone._regex = pattern;
+    return clone;
+  }
+  startsWith(prefix) {
+    const clone = this._clone();
+    clone._startsWith = prefix;
+    return clone;
+  }
+  endsWith(suffix) {
+    const clone = this._clone();
+    clone._endsWith = suffix;
+    return clone;
+  }
+  includes(substring) {
+    const clone = this._clone();
+    clone._includes = substring;
+    return clone;
+  }
+  uppercase() {
+    const clone = this._clone();
+    clone._uppercase = true;
+    return clone;
+  }
+  lowercase() {
+    const clone = this._clone();
+    clone._lowercase = true;
+    return clone;
+  }
+  trim() {
+    const clone = this._clone();
+    clone._trim = true;
+    return clone;
+  }
+  toLowerCase() {
+    const clone = this._clone();
+    clone._toLowerCase = true;
+    return clone;
+  }
+  toUpperCase() {
+    const clone = this._clone();
+    clone._toUpperCase = true;
+    return clone;
+  }
+  normalize() {
+    const clone = this._clone();
+    clone._normalize = true;
+    return clone;
+  }
+  _schemaType() {
+    return "string" /* String */;
+  }
+  _toJSONSchema(_tracker) {
+    const schema = { type: "string" };
+    if (this._min !== undefined)
+      schema.minLength = this._min;
+    if (this._max !== undefined)
+      schema.maxLength = this._max;
+    if (this._regex !== undefined)
+      schema.pattern = this._regex.source;
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new StringSchema);
+    clone._min = this._min;
+    clone._minMessage = this._minMessage;
+    clone._max = this._max;
+    clone._maxMessage = this._maxMessage;
+    clone._length = this._length;
+    clone._lengthMessage = this._lengthMessage;
+    clone._regex = this._regex;
+    clone._startsWith = this._startsWith;
+    clone._endsWith = this._endsWith;
+    clone._includes = this._includes;
+    clone._uppercase = this._uppercase;
+    clone._lowercase = this._lowercase;
+    clone._trim = this._trim;
+    clone._toLowerCase = this._toLowerCase;
+    clone._toUpperCase = this._toUpperCase;
+    clone._normalize = this._normalize;
+    return clone;
+  }
+}
+
+// src/schemas/coerced.ts
+class CoercedStringSchema extends StringSchema {
+  _parse(value, ctx) {
+    return super._parse(value == null ? "" : String(value), ctx);
+  }
+  _clone() {
+    return Object.assign(new CoercedStringSchema, super._clone());
+  }
+}
+
+class CoercedNumberSchema extends NumberSchema {
+  _parse(value, ctx) {
+    return super._parse(Number(value), ctx);
+  }
+  _clone() {
+    return Object.assign(new CoercedNumberSchema, super._clone());
+  }
+}
+
+class CoercedBooleanSchema extends BooleanSchema {
+  _parse(value, ctx) {
+    return super._parse(Boolean(value), ctx);
+  }
+  _clone() {
+    return Object.assign(new CoercedBooleanSchema, super._clone());
+  }
+}
+
+class CoercedBigIntSchema extends BigIntSchema {
+  _parse(value, ctx) {
+    if (typeof value === "bigint")
+      return super._parse(value, ctx);
+    try {
+      return super._parse(BigInt(value), ctx);
+    } catch {
+      ctx.addIssue({ code: "invalid_type" /* InvalidType */, message: "Expected value coercible to bigint" });
+      return value;
+    }
+  }
+  _clone() {
+    return Object.assign(new CoercedBigIntSchema, super._clone());
+  }
+}
+
+class CoercedDateSchema extends DateSchema {
+  _parse(value, ctx) {
+    if (value instanceof Date)
+      return super._parse(value, ctx);
+    return super._parse(new Date(value), ctx);
+  }
+  _clone() {
+    return Object.assign(new CoercedDateSchema, super._clone());
+  }
+}
+// src/schemas/custom.ts
+class CustomSchema extends Schema {
+  _check;
+  _message;
+  constructor(check, message) {
+    super();
+    this._check = check;
+    this._message = message ?? "Custom validation failed";
+  }
+  _parse(value, ctx) {
+    if (!this._check(value)) {
+      ctx.addIssue({ code: "custom" /* Custom */, message: this._message });
+    }
+    return value;
+  }
+  _schemaType() {
+    return "custom" /* Custom */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new CustomSchema(this._check, this._message));
+  }
+}
+// src/schemas/literal.ts
+class LiteralSchema extends Schema {
+  _value;
+  constructor(value) {
+    super();
+    this._value = value;
+  }
+  get value() {
+    return this._value;
+  }
+  _parse(value, ctx) {
+    if (value !== this._value) {
+      ctx.addIssue({
+        code: "invalid_literal" /* InvalidLiteral */,
+        message: `Expected ${JSON.stringify(this._value)}, received ${JSON.stringify(value)}`
+      });
+    }
+    return value;
+  }
+  _schemaType() {
+    return "literal" /* Literal */;
+  }
+  _toJSONSchema(_tracker) {
+    return { const: this._value };
+  }
+  _clone() {
+    return this._cloneBase(new LiteralSchema(this._value));
+  }
+}
+
+// src/schemas/discriminated-union.ts
+function receivedType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+
+class DiscriminatedUnionSchema extends Schema {
+  _discriminator;
+  _options;
+  _lookup;
+  constructor(discriminator, options) {
+    super();
+    this._discriminator = discriminator;
+    this._options = options;
+    this._lookup = new Map;
+    for (const option of options) {
+      const discriminatorSchema = option.shape[discriminator];
+      if (!(discriminatorSchema instanceof LiteralSchema)) {
+        throw new Error(`Discriminated union requires all options to have a literal "${discriminator}" property`);
+      }
+      this._lookup.set(discriminatorSchema.value, option);
+    }
+  }
+  _parse(value, ctx) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected object, received ${receivedType(value)}`
+      });
+      return value;
+    }
+    const obj = value;
+    const discriminatorValue = obj[this._discriminator];
+    if (discriminatorValue === undefined) {
+      ctx.addIssue({
+        code: "invalid_union" /* InvalidUnion */,
+        message: `Missing discriminator property "${this._discriminator}"`
+      });
+      return value;
+    }
+    const matchedSchema = this._lookup.get(discriminatorValue);
+    if (!matchedSchema) {
+      const expected = [...this._lookup.keys()].map((k) => `'${k}'`).join(" | ");
+      ctx.addIssue({
+        code: "invalid_union" /* InvalidUnion */,
+        message: `Invalid discriminator value. Expected ${expected}, received '${discriminatorValue}'`
+      });
+      return value;
+    }
+    return matchedSchema._runPipeline(value, ctx);
+  }
+  _schemaType() {
+    return "discriminatedUnion" /* DiscriminatedUnion */;
+  }
+  _toJSONSchema(tracker) {
+    return {
+      oneOf: this._options.map((option) => option._toJSONSchemaWithRefs(tracker)),
+      discriminator: { propertyName: this._discriminator }
+    };
+  }
+  _clone() {
+    return this._cloneBase(new DiscriminatedUnionSchema(this._discriminator, this._options));
+  }
+}
+// src/schemas/enum.ts
+class EnumSchema extends Schema {
+  _values;
+  constructor(values) {
+    super();
+    this._values = values;
+  }
+  _parse(value, ctx) {
+    if (!this._values.includes(value)) {
+      ctx.addIssue({
+        code: "invalid_enum_value" /* InvalidEnumValue */,
+        message: `Invalid enum value. Expected ${this._values.map((v) => `'${v}'`).join(" | ")}, received '${value}'`
+      });
+    }
+    return value;
+  }
+  _schemaType() {
+    return "enum" /* Enum */;
+  }
+  _toJSONSchema(_tracker) {
+    return { enum: [...this._values] };
+  }
+  exclude(values) {
+    const remaining = this._values.filter((v) => !values.includes(v));
+    const schema = new EnumSchema(remaining);
+    return this._cloneBase(schema);
+  }
+  extract(values) {
+    const schema = new EnumSchema(values);
+    return this._cloneBase(schema);
+  }
+  _clone() {
+    return this._cloneBase(new EnumSchema(this._values));
+  }
+}
+// src/schemas/file.ts
+class FileSchema extends Schema {
+  _parse(value, ctx) {
+    if (!(value instanceof Blob)) {
+      ctx.addIssue({ code: "invalid_type" /* InvalidType */, message: "Expected File or Blob" });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "file" /* File */;
+  }
+  _toJSONSchema(_tracker) {
+    return { type: "string", contentMediaType: "application/octet-stream" };
+  }
+  _clone() {
+    return this._cloneBase(new FileSchema);
+  }
+}
+// src/schemas/formats/format-schema.ts
+class FormatSchema extends StringSchema {
+  _jsonSchemaExtra() {
+    return;
+  }
+  _parse(value, ctx) {
+    const result = super._parse(value, ctx);
+    if (ctx.hasIssues())
+      return result;
+    if (!this._validate(result)) {
+      ctx.addIssue({ code: "invalid_string" /* InvalidString */, message: this._errorMessage });
+    }
+    return result;
+  }
+  _toJSONSchema(tracker) {
+    const extra = this._jsonSchemaExtra();
+    if (!extra)
+      return super._toJSONSchema(tracker);
+    return { ...super._toJSONSchema(tracker), ...extra };
+  }
+  _clone() {
+    const Ctor = this.constructor;
+    return Object.assign(new Ctor, super._clone());
+  }
+}
+
+// src/schemas/formats/base64.ts
+var BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
+
+class Base64Schema extends FormatSchema {
+  _errorMessage = "Invalid base64 string";
+  _validate(value) {
+    return BASE64_RE.test(value) && value.length % 4 === 0;
+  }
+  _jsonSchemaExtra() {
+    return { contentEncoding: "base64" };
+  }
+}
+// src/schemas/formats/cuid.ts
+var CUID_RE = /^c[a-z0-9]{24}$/;
+
+class CuidSchema extends FormatSchema {
+  _errorMessage = "Invalid CUID";
+  _validate(value) {
+    return CUID_RE.test(value);
+  }
+}
+// src/schemas/formats/email.ts
+var EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+class EmailSchema extends FormatSchema {
+  _errorMessage = "Invalid email";
+  _validate(value) {
+    return EMAIL_RE.test(value);
+  }
+  _jsonSchemaExtra() {
+    return { format: "email" };
+  }
+}
+// src/schemas/formats/hex.ts
+var HEX_RE = /^[0-9a-fA-F]+$/;
+
+class HexSchema extends FormatSchema {
+  _errorMessage = "Invalid hex string";
+  _validate(value) {
+    return HEX_RE.test(value);
+  }
+  _jsonSchemaExtra() {
+    return { pattern: "^[0-9a-fA-F]+$" };
+  }
+}
+// src/schemas/formats/hostname.ts
+var HOSTNAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+class HostnameSchema extends FormatSchema {
+  _errorMessage = "Invalid hostname";
+  _validate(value) {
+    return HOSTNAME_RE.test(value) && value.length <= 253;
+  }
+  _jsonSchemaExtra() {
+    return { format: "hostname" };
+  }
+}
+// src/schemas/formats/ipv4.ts
+var IPV4_RE = /^(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})\.(0|[1-9]\d{0,2})$/;
+
+class Ipv4Schema extends FormatSchema {
+  _errorMessage = "Invalid IPv4 address";
+  _validate(value) {
+    const match = IPV4_RE.exec(value);
+    if (!match)
+      return false;
+    return [match[1], match[2], match[3], match[4]].every((o) => Number(o) <= 255);
+  }
+  _jsonSchemaExtra() {
+    return { format: "ipv4" };
+  }
+}
+// src/schemas/formats/ipv6.ts
+var IPV6_RE = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?[0-9])?[0-9])\.){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?[0-9])?[0-9])\.){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9]))$/;
+
+class Ipv6Schema extends FormatSchema {
+  _errorMessage = "Invalid IPv6 address";
+  _validate(value) {
+    return IPV6_RE.test(value);
+  }
+  _jsonSchemaExtra() {
+    return { format: "ipv6" };
+  }
+}
+// src/schemas/formats/iso.ts
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_TIME_RE = /^\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/;
+var ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/;
+var ISO_DURATION_RE = /^P(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/;
+function validateDateRange(value) {
+  const parts = value.split("-").map(Number);
+  const y = parts[0] ?? 0;
+  const m = parts[1] ?? 0;
+  const d = parts[2] ?? 0;
+  const date = new Date(y, m - 1, d);
+  return date.getFullYear() === y && date.getMonth() === m - 1 && date.getDate() === d;
+}
+function validateTimeRange(value) {
+  const parts = value.split(":").map((v) => Number(v.replace(/[^0-9.]/g, "")));
+  const h = parts[0] ?? 0;
+  const min = parts[1] ?? 0;
+  const s = parts[2] ?? 0;
+  return h >= 0 && h <= 23 && min >= 0 && min <= 59 && s >= 0 && s <= 59;
+}
+
+class IsoDateSchema extends FormatSchema {
+  _errorMessage = "Invalid ISO date";
+  _validate(value) {
+    return ISO_DATE_RE.test(value) && validateDateRange(value);
+  }
+  _jsonSchemaExtra() {
+    return { format: "date" };
+  }
+}
+
+class IsoTimeSchema extends FormatSchema {
+  _errorMessage = "Invalid ISO time";
+  _validate(value) {
+    return ISO_TIME_RE.test(value) && validateTimeRange(value);
+  }
+  _jsonSchemaExtra() {
+    return { format: "time" };
+  }
+}
+
+class IsoDatetimeSchema extends FormatSchema {
+  _errorMessage = "Invalid ISO datetime";
+  _validate(value) {
+    if (!ISO_DATETIME_RE.test(value))
+      return false;
+    const parts = value.split("T");
+    const datePart = parts[0] ?? "";
+    const timePart = parts[1] ?? "";
+    return validateDateRange(datePart) && validateTimeRange(timePart);
+  }
+  _jsonSchemaExtra() {
+    return { format: "date-time" };
+  }
+}
+
+class IsoDurationSchema extends FormatSchema {
+  _errorMessage = "Invalid ISO duration";
+  _validate(value) {
+    return ISO_DURATION_RE.test(value) && value !== "P";
+  }
+  _jsonSchemaExtra() {
+    return { format: "duration" };
+  }
+}
+// src/schemas/formats/jwt.ts
+var JWT_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+
+class JwtSchema extends FormatSchema {
+  _errorMessage = "Invalid JWT";
+  _validate(value) {
+    return JWT_RE.test(value);
+  }
+}
+// src/schemas/formats/nanoid.ts
+var NANOID_RE = /^[A-Za-z0-9_-]{21}$/;
+
+class NanoidSchema extends FormatSchema {
+  _errorMessage = "Invalid nanoid";
+  _validate(value) {
+    return NANOID_RE.test(value);
+  }
+}
+// src/schemas/formats/ulid.ts
+var ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+
+class UlidSchema extends FormatSchema {
+  _errorMessage = "Invalid ULID";
+  _validate(value) {
+    return ULID_RE.test(value);
+  }
+}
+// src/schemas/formats/url.ts
+class UrlSchema extends FormatSchema {
+  _errorMessage = "Invalid URL";
+  _validate(value) {
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  _jsonSchemaExtra() {
+    return { format: "uri" };
+  }
+}
+// src/schemas/formats/uuid.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+class UuidSchema extends FormatSchema {
+  _errorMessage = "Invalid UUID";
+  _validate(value) {
+    return UUID_RE.test(value);
+  }
+  _jsonSchemaExtra() {
+    return { format: "uuid" };
+  }
+}
+// src/schemas/instanceof.ts
+class InstanceOfSchema extends Schema {
+  _cls;
+  constructor(cls) {
+    super();
+    this._cls = cls;
+  }
+  _parse(value, ctx) {
+    if (!(value instanceof this._cls)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected instance of ${this._cls.name}`
+      });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "instanceof" /* InstanceOf */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new InstanceOfSchema(this._cls));
+  }
+}
+// src/schemas/intersection.ts
+class IntersectionSchema extends Schema {
+  _left;
+  _right;
+  constructor(left, right) {
+    super();
+    this._left = left;
+    this._right = right;
+  }
+  _parse(value, ctx) {
+    const leftResult = this._left.safeParse(value);
+    const rightResult = this._right.safeParse(value);
+    if (!leftResult.success || !rightResult.success) {
+      ctx.addIssue({
+        code: "invalid_intersection" /* InvalidIntersection */,
+        message: "Value does not satisfy intersection"
+      });
+      return value;
+    }
+    if (typeof leftResult.data === "object" && leftResult.data !== null && typeof rightResult.data === "object" && rightResult.data !== null) {
+      return { ...leftResult.data, ...rightResult.data };
+    }
+    return leftResult.data;
+  }
+  _schemaType() {
+    return "intersection" /* Intersection */;
+  }
+  _toJSONSchema(tracker) {
+    return {
+      allOf: [
+        this._left._toJSONSchemaWithRefs(tracker),
+        this._right._toJSONSchemaWithRefs(tracker)
+      ]
+    };
+  }
+  _clone() {
+    return this._cloneBase(new IntersectionSchema(this._left, this._right));
+  }
+}
+// src/schemas/lazy.ts
+class LazySchema extends Schema {
+  _getter;
+  _cached;
+  constructor(getter) {
+    super();
+    this._getter = getter;
+  }
+  _resolve() {
+    if (!this._cached) {
+      this._cached = this._getter();
+    }
+    return this._cached;
+  }
+  _parse(value, ctx) {
+    return this._resolve()._runPipeline(value, ctx);
+  }
+  _schemaType() {
+    return "lazy" /* Lazy */;
+  }
+  _toJSONSchema(tracker) {
+    return this._resolve()._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new LazySchema(this._getter));
+  }
+}
+// src/schemas/map.ts
+class MapSchema extends Schema {
+  _keySchema;
+  _valueSchema;
+  constructor(keySchema, valueSchema) {
+    super();
+    this._keySchema = keySchema;
+    this._valueSchema = valueSchema;
+  }
+  _parse(value, ctx) {
+    if (!(value instanceof Map)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected Map, received ${typeof value}`
+      });
+      return value;
+    }
+    const result = new Map;
+    let index = 0;
+    for (const [k, v] of value) {
+      ctx.pushPath(index);
+      const parsedKey = this._keySchema._runPipeline(k, ctx);
+      const parsedValue = this._valueSchema._runPipeline(v, ctx);
+      result.set(parsedKey, parsedValue);
+      ctx.popPath();
+      index++;
+    }
+    return result;
+  }
+  _schemaType() {
+    return "map" /* Map */;
+  }
+  _toJSONSchema(tracker) {
+    return {
+      type: "array",
+      items: {
+        type: "array",
+        prefixItems: [
+          this._keySchema._toJSONSchemaWithRefs(tracker),
+          this._valueSchema._toJSONSchemaWithRefs(tracker)
+        ],
+        items: false
+      }
+    };
+  }
+  _clone() {
+    return this._cloneBase(new MapSchema(this._keySchema, this._valueSchema));
+  }
+}
+// src/schemas/nan.ts
+class NanSchema extends Schema {
+  _parse(value, ctx) {
+    if (typeof value !== "number" || !Number.isNaN(value)) {
+      ctx.addIssue({ code: "invalid_type" /* InvalidType */, message: "Expected NaN" });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "nan" /* NaN */;
+  }
+  _toJSONSchema(_tracker) {
+    return { not: {} };
+  }
+  _clone() {
+    return this._cloneBase(new NanSchema);
+  }
+}
+// src/schemas/object.ts
+function receivedType2(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+
+class ObjectSchema extends Schema {
+  _shape;
+  _unknownKeys = "strip";
+  _catchall;
+  constructor(shape) {
+    super();
+    this._shape = shape;
+  }
+  get shape() {
+    return this._shape;
+  }
+  _isOptionalKey(schema) {
+    return schema instanceof OptionalSchema || schema instanceof DefaultSchema;
+  }
+  _parse(value, ctx) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected object, received ${receivedType2(value)}`
+      });
+      return value;
+    }
+    const obj = value;
+    const result = {};
+    const shapeKeys = new Set(Object.keys(this._shape));
+    for (const key of shapeKeys) {
+      const schema = this._shape[key];
+      if (!(key in obj) && schema && !this._isOptionalKey(schema)) {
+        ctx.addIssue({
+          code: "missing_property" /* MissingProperty */,
+          message: `Missing required property "${key}"`,
+          path: [key]
+        });
+        continue;
+      }
+      ctx.pushPath(key);
+      result[key] = schema?._runPipeline(obj[key], ctx);
+      ctx.popPath();
+    }
+    const unknownKeys = Object.keys(obj).filter((k) => !shapeKeys.has(k));
+    if (unknownKeys.length > 0) {
+      if (this._catchall) {
+        for (const key of unknownKeys) {
+          ctx.pushPath(key);
+          result[key] = this._catchall._runPipeline(obj[key], ctx);
+          ctx.popPath();
+        }
+      } else if (this._unknownKeys === "strict") {
+        ctx.addIssue({
+          code: "unrecognized_keys" /* UnrecognizedKeys */,
+          message: `Unrecognized key(s) in object: ${unknownKeys.map((k) => `"${k}"`).join(", ")}`
+        });
+      } else if (this._unknownKeys === "passthrough") {
+        for (const key of unknownKeys) {
+          result[key] = obj[key];
+        }
+      }
+    }
+    return result;
+  }
+  strict() {
+    const clone = this._clone();
+    clone._unknownKeys = "strict";
+    return clone;
+  }
+  passthrough() {
+    const clone = this._clone();
+    clone._unknownKeys = "passthrough";
+    return clone;
+  }
+  extend(extension) {
+    return new ObjectSchema({ ...this._shape, ...extension });
+  }
+  merge(other) {
+    return new ObjectSchema({ ...this._shape, ...other.shape });
+  }
+  pick(...keys) {
+    const picked = {};
+    for (const key of keys) {
+      const schema = this._shape[key];
+      if (schema)
+        picked[key] = schema;
+    }
+    return new ObjectSchema(picked);
+  }
+  required() {
+    const requiredShape = {};
+    for (const [key, schema] of Object.entries(this._shape)) {
+      if (schema instanceof OptionalSchema || schema instanceof DefaultSchema) {
+        requiredShape[key] = schema.unwrap();
+      } else {
+        requiredShape[key] = schema;
+      }
+    }
+    return new ObjectSchema(requiredShape);
+  }
+  partial() {
+    const partialShape = {};
+    for (const [key, schema] of Object.entries(this._shape)) {
+      partialShape[key] = schema instanceof OptionalSchema ? schema : schema.optional();
+    }
+    return new ObjectSchema(partialShape);
+  }
+  omit(...keys) {
+    const keysToOmit = new Set(keys);
+    const remaining = {};
+    for (const [key, schema] of Object.entries(this._shape)) {
+      if (!keysToOmit.has(key)) {
+        remaining[key] = schema;
+      }
+    }
+    return new ObjectSchema(remaining);
+  }
+  keyof() {
+    return Object.keys(this._shape);
+  }
+  catchall(schema) {
+    const clone = this._clone();
+    clone._catchall = schema;
+    clone._unknownKeys = "strip";
+    return clone;
+  }
+  _schemaType() {
+    return "object" /* Object */;
+  }
+  _toJSONSchema(tracker) {
+    const properties = {};
+    const required = [];
+    for (const [key, schema2] of Object.entries(this._shape)) {
+      properties[key] = schema2._toJSONSchemaWithRefs(tracker);
+      if (!this._isOptionalKey(schema2)) {
+        required.push(key);
+      }
+    }
+    const schema = { type: "object", properties };
+    if (required.length > 0) {
+      schema.required = required;
+    }
+    if (this._unknownKeys === "strict") {
+      schema.additionalProperties = false;
+    }
+    if (this._catchall) {
+      schema.additionalProperties = this._catchall._toJSONSchemaWithRefs(tracker);
+    }
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new ObjectSchema(this._shape));
+    clone._unknownKeys = this._unknownKeys;
+    clone._catchall = this._catchall;
+    return clone;
+  }
+}
+// src/schemas/record.ts
+function receivedType3(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+
+class RecordSchema extends Schema {
+  _keySchema;
+  _valueSchema;
+  constructor(keyOrValue, valueSchema) {
+    super();
+    if (valueSchema !== undefined) {
+      this._keySchema = keyOrValue;
+      this._valueSchema = valueSchema;
+    } else {
+      this._keySchema = undefined;
+      this._valueSchema = keyOrValue;
+    }
+  }
+  _parse(value, ctx) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected object, received ${receivedType3(value)}`
+      });
+      return value;
+    }
+    const obj = value;
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      ctx.pushPath(key);
+      if (this._keySchema) {
+        this._keySchema._runPipeline(key, ctx);
+      }
+      result[key] = this._valueSchema._runPipeline(obj[key], ctx);
+      ctx.popPath();
+    }
+    return result;
+  }
+  _schemaType() {
+    return "record" /* Record */;
+  }
+  _toJSONSchema(tracker) {
+    return {
+      type: "object",
+      additionalProperties: this._valueSchema._toJSONSchemaWithRefs(tracker)
+    };
+  }
+  _clone() {
+    if (this._keySchema) {
+      return this._cloneBase(new RecordSchema(this._keySchema, this._valueSchema));
+    }
+    return this._cloneBase(new RecordSchema(this._valueSchema));
+  }
+}
+// src/schemas/set.ts
+class SetSchema extends Schema {
+  _valueSchema;
+  _min;
+  _max;
+  _size;
+  constructor(valueSchema) {
+    super();
+    this._valueSchema = valueSchema;
+  }
+  _parse(value, ctx) {
+    if (!(value instanceof Set)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected Set, received ${typeof value}`
+      });
+      return value;
+    }
+    const result = new Set;
+    let index = 0;
+    for (const item of value) {
+      ctx.pushPath(index);
+      result.add(this._valueSchema._runPipeline(item, ctx));
+      ctx.popPath();
+      index++;
+    }
+    if (this._min !== undefined && result.size < this._min) {
+      ctx.addIssue({
+        code: "too_small" /* TooSmall */,
+        message: `Set must contain at least ${this._min} element(s)`
+      });
+    }
+    if (this._max !== undefined && result.size > this._max) {
+      ctx.addIssue({
+        code: "too_big" /* TooBig */,
+        message: `Set must contain at most ${this._max} element(s)`
+      });
+    }
+    if (this._size !== undefined && result.size !== this._size) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Set must contain exactly ${this._size} element(s)`
+      });
+    }
+    return result;
+  }
+  min(n) {
+    const clone = this._clone();
+    clone._min = n;
+    return clone;
+  }
+  max(n) {
+    const clone = this._clone();
+    clone._max = n;
+    return clone;
+  }
+  size(n) {
+    const clone = this._clone();
+    clone._size = n;
+    return clone;
+  }
+  _schemaType() {
+    return "set" /* Set */;
+  }
+  _toJSONSchema(tracker) {
+    const schema = {
+      type: "array",
+      uniqueItems: true,
+      items: this._valueSchema._toJSONSchemaWithRefs(tracker)
+    };
+    if (this._min !== undefined)
+      schema.minItems = this._min;
+    if (this._max !== undefined)
+      schema.maxItems = this._max;
+    if (this._size !== undefined) {
+      schema.minItems = this._size;
+      schema.maxItems = this._size;
+    }
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new SetSchema(this._valueSchema));
+    clone._min = this._min;
+    clone._max = this._max;
+    clone._size = this._size;
+    return clone;
+  }
+}
+// src/schemas/special.ts
+class AnySchema extends Schema {
+  _parse(value, _ctx) {
+    return value;
+  }
+  _schemaType() {
+    return "any" /* Any */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new AnySchema);
+  }
+}
+
+class UnknownSchema extends Schema {
+  _parse(value, _ctx) {
+    return value;
+  }
+  _schemaType() {
+    return "unknown" /* Unknown */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new UnknownSchema);
+  }
+}
+
+class NullSchema extends Schema {
+  _parse(value, ctx) {
+    if (value !== null) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected null, received ${typeof value}`
+      });
+      return null;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "null" /* Null */;
+  }
+  _toJSONSchema(_tracker) {
+    return { type: "null" };
+  }
+  _clone() {
+    return this._cloneBase(new NullSchema);
+  }
+}
+
+class UndefinedSchema extends Schema {
+  _parse(value, ctx) {
+    if (value !== undefined) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected undefined, received ${typeof value}`
+      });
+      return;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "undefined" /* Undefined */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new UndefinedSchema);
+  }
+}
+
+class VoidSchema extends Schema {
+  _parse(value, ctx) {
+    if (value !== undefined) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected void (undefined), received ${typeof value}`
+      });
+    }
+  }
+  _schemaType() {
+    return "void" /* Void */;
+  }
+  _toJSONSchema(_tracker) {
+    return {};
+  }
+  _clone() {
+    return this._cloneBase(new VoidSchema);
+  }
+}
+
+class NeverSchema extends Schema {
+  _parse(value, ctx) {
+    ctx.addIssue({ code: "invalid_type" /* InvalidType */, message: "No value is allowed" });
+    return value;
+  }
+  _schemaType() {
+    return "never" /* Never */;
+  }
+  _toJSONSchema(_tracker) {
+    return { not: {} };
+  }
+  _clone() {
+    return this._cloneBase(new NeverSchema);
+  }
+}
+// src/schemas/symbol.ts
+class SymbolSchema extends Schema {
+  _parse(value, ctx) {
+    if (typeof value !== "symbol") {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected symbol, received ${typeof value}`
+      });
+      return value;
+    }
+    return value;
+  }
+  _schemaType() {
+    return "symbol" /* Symbol */;
+  }
+  _toJSONSchema(_tracker) {
+    return { not: {} };
+  }
+  _clone() {
+    return this._cloneBase(new SymbolSchema);
+  }
+}
+// src/schemas/tuple.ts
+class TupleSchema extends Schema {
+  _items;
+  _rest;
+  constructor(items) {
+    super();
+    this._items = items;
+  }
+  _parse(value, ctx) {
+    if (!Array.isArray(value)) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected array, received ${typeof value}`
+      });
+      return value;
+    }
+    if (!this._rest && value.length !== this._items.length) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected array of length ${this._items.length}, received ${value.length}`
+      });
+    }
+    if (this._rest && value.length < this._items.length) {
+      ctx.addIssue({
+        code: "invalid_type" /* InvalidType */,
+        message: `Expected at least ${this._items.length} element(s), received ${value.length}`
+      });
+    }
+    const result = [];
+    for (let i = 0;i < this._items.length; i++) {
+      ctx.pushPath(i);
+      result.push(this._items[i]?._runPipeline(value[i], ctx));
+      ctx.popPath();
+    }
+    if (this._rest) {
+      for (let i = this._items.length;i < value.length; i++) {
+        ctx.pushPath(i);
+        result.push(this._rest._runPipeline(value[i], ctx));
+        ctx.popPath();
+      }
+    }
+    return result;
+  }
+  rest(schema) {
+    const clone = this._clone();
+    clone._rest = schema;
+    return clone;
+  }
+  _schemaType() {
+    return "tuple" /* Tuple */;
+  }
+  _toJSONSchema(tracker) {
+    const prefixItems = this._items.map((item) => item._toJSONSchemaWithRefs(tracker));
+    const schema = { type: "array", prefixItems };
+    schema.items = this._rest ? this._rest._toJSONSchemaWithRefs(tracker) : false;
+    return schema;
+  }
+  _clone() {
+    const clone = this._cloneBase(new TupleSchema(this._items));
+    clone._rest = this._rest;
+    return clone;
+  }
+}
+// src/schemas/union.ts
+class UnionSchema extends Schema {
+  _options;
+  constructor(options) {
+    super();
+    this._options = options;
+  }
+  _parse(value, ctx) {
+    for (const option of this._options) {
+      const result = option.safeParse(value);
+      if (result.success) {
+        return result.data;
+      }
+    }
+    ctx.addIssue({
+      code: "invalid_union" /* InvalidUnion */,
+      message: `Invalid input: value does not match any option in the union`
+    });
+    return value;
+  }
+  _schemaType() {
+    return "union" /* Union */;
+  }
+  _toJSONSchema(tracker) {
+    return {
+      anyOf: this._options.map((option) => option._toJSONSchemaWithRefs(tracker))
+    };
+  }
+  _clone() {
+    return this._cloneBase(new UnionSchema(this._options));
+  }
+}
+// src/transforms/preprocess.ts
+class PreprocessSchema extends Schema {
+  _preprocess;
+  _inner;
+  constructor(preprocess, inner) {
+    super();
+    this._preprocess = preprocess;
+    this._inner = inner;
+  }
+  _parse(value, ctx) {
+    let processed;
+    try {
+      processed = this._preprocess(value);
+    } catch (e) {
+      ctx.addIssue({
+        code: "custom" /* Custom */,
+        message: e instanceof Error ? e.message : "Preprocess failed"
+      });
+      return value;
+    }
+    return this._inner._runPipeline(processed, ctx);
+  }
+  _schemaType() {
+    return this._inner._schemaType();
+  }
+  _toJSONSchema(tracker) {
+    return this._inner._toJSONSchemaWithRefs(tracker);
+  }
+  _clone() {
+    return this._cloneBase(new PreprocessSchema(this._preprocess, this._inner));
+  }
+}
+function preprocess(fn, schema) {
+  return new PreprocessSchema(fn, schema);
+}
+// src/index.ts
+var s = {
+  string: () => new StringSchema,
+  number: () => new NumberSchema,
+  boolean: () => new BooleanSchema,
+  bigint: () => new BigIntSchema,
+  date: () => new DateSchema,
+  symbol: () => new SymbolSchema,
+  nan: () => new NanSchema,
+  int: () => new NumberSchema().int(),
+  any: () => new AnySchema,
+  unknown: () => new UnknownSchema,
+  null: () => new NullSchema,
+  undefined: () => new UndefinedSchema,
+  void: () => new VoidSchema,
+  never: () => new NeverSchema,
+  object: (shape) => new ObjectSchema(shape),
+  array: (itemSchema) => new ArraySchema(itemSchema),
+  tuple: (items) => new TupleSchema(items),
+  enum: (values) => new EnumSchema(values),
+  literal: (value) => new LiteralSchema(value),
+  union: (options) => new UnionSchema(options),
+  discriminatedUnion: (discriminator, options) => new DiscriminatedUnionSchema(discriminator, options),
+  intersection: (left, right) => new IntersectionSchema(left, right),
+  record: (valueSchema) => new RecordSchema(valueSchema),
+  map: (keySchema, valueSchema) => new MapSchema(keySchema, valueSchema),
+  set: (valueSchema) => new SetSchema(valueSchema),
+  file: () => new FileSchema,
+  custom: (check, message) => new CustomSchema(check, message),
+  instanceof: (cls) => new InstanceOfSchema(cls),
+  lazy: (getter) => new LazySchema(getter),
+  email: () => new EmailSchema,
+  uuid: () => new UuidSchema,
+  url: () => new UrlSchema,
+  hostname: () => new HostnameSchema,
+  ipv4: () => new Ipv4Schema,
+  ipv6: () => new Ipv6Schema,
+  base64: () => new Base64Schema,
+  hex: () => new HexSchema,
+  jwt: () => new JwtSchema,
+  cuid: () => new CuidSchema,
+  ulid: () => new UlidSchema,
+  nanoid: () => new NanoidSchema,
+  iso: {
+    date: () => new IsoDateSchema,
+    time: () => new IsoTimeSchema,
+    datetime: () => new IsoDatetimeSchema,
+    duration: () => new IsoDurationSchema
+  },
+  coerce: {
+    string: () => new CoercedStringSchema,
+    number: () => new CoercedNumberSchema,
+    boolean: () => new CoercedBooleanSchema,
+    bigint: () => new CoercedBigIntSchema,
+    date: () => new CoercedDateSchema
+  }
+};
+var schema = s;
+export {
+  toJSONSchema,
+  schema,
+  s,
+  preprocess,
+  VoidSchema,
+  UuidSchema,
+  UrlSchema,
+  UnknownSchema,
+  UnionSchema,
+  UndefinedSchema,
+  UlidSchema,
+  TupleSchema,
+  TransformSchema,
+  SymbolSchema,
+  SuperRefinedSchema,
+  StringSchema,
+  SetSchema,
+  SchemaType,
+  SchemaRegistry,
+  Schema,
+  RefinedSchema,
+  RefTracker,
+  RecordSchema,
+  ReadonlySchema,
+  PipeSchema,
+  ParseError,
+  ParseContext,
+  OptionalSchema,
+  ObjectSchema,
+  NumberSchema,
+  NullableSchema,
+  NullSchema,
+  NeverSchema,
+  NanoidSchema,
+  NanSchema,
+  MapSchema,
+  LiteralSchema,
+  LazySchema,
+  JwtSchema,
+  IsoTimeSchema,
+  IsoDurationSchema,
+  IsoDatetimeSchema,
+  IsoDateSchema,
+  Ipv6Schema,
+  Ipv4Schema,
+  IntersectionSchema,
+  InstanceOfSchema,
+  HostnameSchema,
+  HexSchema,
+  FileSchema,
+  ErrorCode,
+  EnumSchema,
+  EmailSchema,
+  DiscriminatedUnionSchema,
+  DefaultSchema,
+  DateSchema,
+  CustomSchema,
+  CuidSchema,
+  CoercedStringSchema,
+  CoercedNumberSchema,
+  CoercedDateSchema,
+  CoercedBooleanSchema,
+  CoercedBigIntSchema,
+  CatchSchema,
+  BrandedSchema,
+  BooleanSchema,
+  BigIntSchema,
+  Base64Schema,
+  ArraySchema,
+  AnySchema
+};