speexjs 0.2.0

package/dist/schema/index.js

@@ -0,0 +1,1160 @@
+// src/schema/messages.ts
+var currentLocale = "id";
+var ID = {
+  required: "Nilai wajib diisi",
+  type_string: "Nilai harus berupa teks",
+  type_number: "Nilai harus berupa angka",
+  type_boolean: "Nilai harus berupa boolean",
+  type_bigint: "Nilai harus berupa BigInt",
+  type_symbol: "Nilai harus berupa Symbol",
+  type_undefined: "Nilai harus berupa undefined",
+  type_null: "Nilai harus berupa null",
+  type_nan: "Nilai harus berupa NaN",
+  type_object: "Nilai harus berupa objek",
+  type_array: "Nilai harus berupa array",
+  type_date: "Nilai harus berupa tanggal yang valid",
+  type_function: "Nilai harus berupa fungsi",
+  type_string_or_number: "Nilai harus berupa teks atau angka",
+  string_min: "Panjang minimal {min} karakter",
+  string_max: "Panjang maksimal {max} karakter",
+  string_length: "Panjang harus tepat {length} karakter",
+  string_email: "Format email tidak valid",
+  string_url: "Format URL tidak valid",
+  string_regex: "Format tidak sesuai dengan pola yang diharapkan",
+  string_includes: 'Teks harus mengandung "{substring}"',
+  string_starts_with: 'Teks harus diawali dengan "{prefix}"',
+  string_ends_with: 'Teks harus diakhiri dengan "{suffix}"',
+  number_min: "Nilai minimal {min}",
+  number_max: "Nilai maksimal {max}",
+  number_int: "Nilai harus bilangan bulat",
+  number_positive: "Nilai harus positif",
+  number_negative: "Nilai harus negatif",
+  number_finite: "Nilai harus terbatas (finite)",
+  number_safe: "Nilai harus dalam batas safe integer",
+  array_min: "Panjang array minimal {min}",
+  array_max: "Panjang array maksimal {max}",
+  array_length: "Panjang array harus tepat {length}",
+  array_nonempty: "Array tidak boleh kosong",
+  array_unique: "Semua elemen array harus unik",
+  object_strict: 'Key "{key}" tidak dikenal',
+  enum_invalid: "Nilai harus salah satu dari: {values}",
+  tuple_length: "Tuple harus memiliki tepat {length} elemen",
+  union_fail: "Nilai tidak cocok dengan skema apapun",
+  intersection_fail: "Nilai tidak cocok dengan interseksi skema",
+  literal_fail: "Nilai harus tepat {expected}",
+  refine_fail: "{message}",
+  date_invalid: "Tanggal tidak valid",
+  date_not_date: "Nilai harus berupa tanggal yang valid",
+  indonesia_nik: "NIK harus 16 digit dan memenuhi format yang valid",
+  indonesia_npwp: "NPWP tidak valid",
+  indonesia_phone: "Nomor telepon Indonesia tidak valid",
+  indonesia_alamat: "Alamat tidak valid (minimal 10 karakter, harus mengandung unsur jalan/RT/RW)",
+  indonesia_kodepos: "Kode pos harus 5 digit angka",
+  indonesia_rekening: "Nomor rekening harus 10-16 digit angka",
+  coerce_number_fail: "Nilai tidak dapat dikonversi menjadi angka",
+  coerce_date_fail: "Nilai tidak dapat dikonversi menjadi tanggal",
+  map_not_map: "Nilai harus berupa Map",
+  set_not_set: "Nilai harus berupa Set"
+};
+var EN = {
+  required: "Value is required",
+  type_string: "Expected a string",
+  type_number: "Expected a number",
+  type_boolean: "Expected a boolean",
+  type_bigint: "Expected a BigInt",
+  type_symbol: "Expected a Symbol",
+  type_undefined: "Expected undefined",
+  type_null: "Expected null",
+  type_nan: "Expected NaN",
+  type_object: "Expected an object",
+  type_array: "Expected an array",
+  type_date: "Expected a valid date",
+  type_function: "Expected a function",
+  type_string_or_number: "Expected a string or number",
+  string_min: "Minimum {min} characters",
+  string_max: "Maximum {max} characters",
+  string_length: "Exactly {length} characters required",
+  string_email: "Invalid email format",
+  string_url: "Invalid URL format",
+  string_regex: "Format does not match expected pattern",
+  string_includes: 'Must contain "{substring}"',
+  string_starts_with: 'Must start with "{prefix}"',
+  string_ends_with: 'Must end with "{suffix}"',
+  number_min: "Minimum value is {min}",
+  number_max: "Maximum value is {max}",
+  number_int: "Expected an integer",
+  number_positive: "Expected a positive number",
+  number_negative: "Expected a negative number",
+  number_finite: "Expected a finite number",
+  number_safe: "Expected a safe integer",
+  array_min: "Minimum {min} items",
+  array_max: "Maximum {max} items",
+  array_length: "Exactly {length} items required",
+  array_nonempty: "Array must not be empty",
+  array_unique: "All items must be unique",
+  object_strict: 'Unexpected key: "{key}"',
+  enum_invalid: "Value must be one of: {values}",
+  tuple_length: "Tuple must have exactly {length} items",
+  union_fail: "Value does not match any schema",
+  intersection_fail: "Value does not match intersection schema",
+  literal_fail: "Value must be {expected}",
+  refine_fail: "{message}",
+  date_invalid: "Invalid date",
+  date_not_date: "Value must be a valid date",
+  indonesia_nik: "NIK must be 16 digits with valid format",
+  indonesia_npwp: "Invalid NPWP format",
+  indonesia_phone: "Invalid Indonesian phone number",
+  indonesia_alamat: "Invalid address (min 10 characters, must contain street/RT/RW elements)",
+  indonesia_kodepos: "Postal code must be 5 digits",
+  indonesia_rekening: "Bank account number must be 10-16 digits",
+  coerce_number_fail: "Value cannot be coerced to a number",
+  coerce_date_fail: "Value cannot be coerced to a date",
+  map_not_map: "Expected a Map",
+  set_not_set: "Expected a Set"
+};
+var store = { ...ID };
+function msg(key, params) {
+  let template = store[key];
+  if (!template) return key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      template = template.replace(`{${k}}`, v !== void 0 ? String(v) : "");
+    }
+  }
+  return template;
+}
+function setLocale(locale) {
+  currentLocale = locale;
+  const source = locale === "id" ? ID : EN;
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      store[key] = source[key];
+    }
+  }
+}
+function getLocale() {
+  return currentLocale;
+}
+
+// src/schema/types.ts
+var SchemaError = class extends Error {
+  path;
+  received;
+  constructor(message, options) {
+    super(message);
+    this.name = "SchemaError";
+    this.path = options?.path ?? "";
+    this.received = options?.received;
+  }
+  toJSON() {
+    return { name: this.name, message: this.message, path: this.path, received: this.received };
+  }
+};
+var Schema = class {
+  parse(value) {
+    return this._parse(value);
+  }
+  safeParse(value) {
+    try {
+      const data = this._parse(value);
+      return { success: true, data };
+    } catch (e) {
+      if (e instanceof SchemaError) {
+        return { success: false, error: e.message };
+      }
+      return { success: false, error: String(e) };
+    }
+  }
+  optional() {
+    return new OptionalSchema(this);
+  }
+  nullable() {
+    return new NullableSchema(this);
+  }
+  default(defaultValue) {
+    return new DefaultSchema(this, defaultValue);
+  }
+  describe(_description) {
+    return this;
+  }
+  refine(fn, message) {
+    return new RefineSchema(this, fn, message);
+  }
+  transform(fn) {
+    return new TransformSchema(this, fn);
+  }
+  /** @internal used by s.enum() etc */
+  get _internal() {
+    return this;
+  }
+};
+var OptionalSchema = class extends Schema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  _parse(value) {
+    if (value === void 0) return void 0;
+    return this.inner._parse(value);
+  }
+};
+var NullableSchema = class extends Schema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  _parse(value) {
+    if (value === null) return null;
+    return this.inner._parse(value);
+  }
+};
+var DefaultSchema = class extends Schema {
+  constructor(inner, defaultValue) {
+    super();
+    this.inner = inner;
+    this.defaultValue = defaultValue;
+  }
+  inner;
+  defaultValue;
+  _parse(value) {
+    if (value === void 0) return this.defaultValue;
+    return this.inner._parse(value);
+  }
+};
+var RefineSchema = class extends Schema {
+  constructor(inner, fn, errorMsg) {
+    super();
+    this.inner = inner;
+    this.fn = fn;
+    this.errorMsg = errorMsg;
+  }
+  inner;
+  fn;
+  errorMsg;
+  _parse(value) {
+    const result = this.inner._parse(value);
+    if (!this.fn(result)) {
+      throw new SchemaError(msg("refine_fail", { message: this.errorMsg }));
+    }
+    return result;
+  }
+};
+var TransformSchema = class extends Schema {
+  constructor(inner, fn) {
+    super();
+    this.inner = inner;
+    this.fn = fn;
+  }
+  inner;
+  fn;
+  _parse(value) {
+    const result = this.inner._parse(value);
+    return this.fn(result);
+  }
+};
+
+// src/schema/primitives.ts
+var StringSchema = class extends Schema {
+  checks = [];
+  min(n) {
+    this.checks.push((val) => {
+      if (val.length < n) throw new SchemaError(msg("string_min", { min: n }));
+    });
+    return this;
+  }
+  max(n) {
+    this.checks.push((val) => {
+      if (val.length > n) throw new SchemaError(msg("string_max", { max: n }));
+    });
+    return this;
+  }
+  length(n) {
+    this.checks.push((val) => {
+      if (val.length !== n) throw new SchemaError(msg("string_length", { length: n }));
+    });
+    return this;
+  }
+  email() {
+    this.checks.push((val) => {
+      if (!isValidEmail(val)) throw new SchemaError(msg("string_email"));
+    });
+    return this;
+  }
+  url() {
+    this.checks.push((val) => {
+      try {
+        const url = new URL(val);
+        if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error();
+      } catch {
+        throw new SchemaError(msg("string_url"));
+      }
+    });
+    return this;
+  }
+  regex(pattern) {
+    this.checks.push((val) => {
+      if (!pattern.test(val)) throw new SchemaError(msg("string_regex"));
+    });
+    return this;
+  }
+  includes(substring) {
+    this.checks.push((val) => {
+      if (!val.includes(substring)) throw new SchemaError(msg("string_includes", { substring }));
+    });
+    return this;
+  }
+  startsWith(prefix) {
+    this.checks.push((val) => {
+      if (!val.startsWith(prefix)) throw new SchemaError(msg("string_starts_with", { prefix }));
+    });
+    return this;
+  }
+  endsWith(suffix) {
+    this.checks.push((val) => {
+      if (!val.endsWith(suffix)) throw new SchemaError(msg("string_ends_with", { suffix }));
+    });
+    return this;
+  }
+  trim() {
+    return new StringTrimSchema(this);
+  }
+  lowercase() {
+    return new StringLowercaseSchema(this);
+  }
+  uppercase() {
+    return new StringUppercaseSchema(this);
+  }
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    for (const check of this.checks) check(value);
+    return value;
+  }
+};
+var StringTrimSchema = class extends Schema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  _parse(value) {
+    const result = this.inner._parse(value);
+    return result.trim();
+  }
+};
+var StringLowercaseSchema = class extends Schema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  _parse(value) {
+    const result = this.inner._parse(value);
+    return result.toLowerCase();
+  }
+};
+var StringUppercaseSchema = class extends Schema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  inner;
+  _parse(value) {
+    const result = this.inner._parse(value);
+    return result.toUpperCase();
+  }
+};
+var NumberSchema = class extends Schema {
+  checks = [];
+  min(n) {
+    this.checks.push((val) => {
+      if (val < n) throw new SchemaError(msg("number_min", { min: n }));
+    });
+    return this;
+  }
+  max(n) {
+    this.checks.push((val) => {
+      if (val > n) throw new SchemaError(msg("number_max", { max: n }));
+    });
+    return this;
+  }
+  int() {
+    this.checks.push((val) => {
+      if (!Number.isInteger(val)) throw new SchemaError(msg("number_int"));
+    });
+    return this;
+  }
+  positive() {
+    this.checks.push((val) => {
+      if (val <= 0) throw new SchemaError(msg("number_positive"));
+    });
+    return this;
+  }
+  negative() {
+    this.checks.push((val) => {
+      if (val >= 0) throw new SchemaError(msg("number_negative"));
+    });
+    return this;
+  }
+  finite() {
+    this.checks.push((val) => {
+      if (!Number.isFinite(val)) throw new SchemaError(msg("number_finite"));
+    });
+    return this;
+  }
+  safe() {
+    this.checks.push((val) => {
+      if (!Number.isSafeInteger(val)) throw new SchemaError(msg("number_safe"));
+    });
+    return this;
+  }
+  _parse(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      throw new SchemaError(msg("type_number"));
+    }
+    for (const check of this.checks) check(value);
+    return value;
+  }
+};
+var BooleanSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "boolean") throw new SchemaError(msg("type_boolean"));
+    return value;
+  }
+};
+var BigIntSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "bigint") throw new SchemaError(msg("type_bigint"));
+    return value;
+  }
+};
+var SymbolSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "symbol") throw new SchemaError(msg("type_symbol"));
+    return value;
+  }
+};
+var UndefinedSchema = class extends Schema {
+  _parse(value) {
+    if (value !== void 0) throw new SchemaError(msg("type_undefined"));
+    return void 0;
+  }
+};
+var NullSchema = class extends Schema {
+  _parse(value) {
+    if (value !== null) throw new SchemaError(msg("type_null"));
+    return null;
+  }
+};
+var NaNSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "number" || !Number.isNaN(value)) {
+      throw new SchemaError(msg("type_nan"));
+    }
+    return value;
+  }
+};
+function isValidEmail(value) {
+  if (value.length > 254) return false;
+  const atIndex = value.lastIndexOf("@");
+  if (atIndex < 1 || atIndex === value.length - 1) return false;
+  const localPart = value.slice(0, atIndex);
+  const domainPart = value.slice(atIndex + 1);
+  if (localPart.length > 64) return false;
+  if (domainPart.length > 255) return false;
+  if (domainPart.split(".").length < 2) return false;
+  if (localPart.startsWith('"') && localPart.endsWith('"')) {
+    if (localPart.length < 2) return false;
+    let i = 1;
+    while (i < localPart.length - 1) {
+      const ch = localPart[i];
+      if (ch === "\\") {
+        i++;
+        if (i >= localPart.length - 1) return false;
+      } else if (ch === '"') {
+        return false;
+      }
+      i++;
+    }
+    return true;
+  }
+  if (localPart.length === 0 || localPart.startsWith(".") || localPart.endsWith(".")) return false;
+  for (let i = 0; i < localPart.length; i++) {
+    const ch = localPart[i];
+    if ('<>=()[]\\,;:@"'.includes(ch)) return false;
+  }
+  for (let i = 1; i < localPart.length; i++) {
+    if (localPart[i] === "." && localPart[i - 1] === ".") return false;
+  }
+  for (const label of domainPart.split(".")) {
+    if (label.length === 0 || label.length > 63) return false;
+    if (label.startsWith("-") || label.endsWith("-")) return false;
+    for (let i = 0; i < label.length; i++) {
+      const ch = label[i];
+      if (!(ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "-")) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/schema/complex.ts
+var ObjectSchema = class _ObjectSchema extends Schema {
+  shape;
+  isStrictMode = false;
+  isPassthroughMode = false;
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  strict() {
+    this.isStrictMode = true;
+    this.isPassthroughMode = false;
+    return this;
+  }
+  passthrough() {
+    this.isPassthroughMode = true;
+    this.isStrictMode = false;
+    return this;
+  }
+  partial() {
+    const newShape = {};
+    for (const key in this.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.shape, key)) {
+        newShape[key] = new OptionalSchema(this.shape[key]);
+      }
+    }
+    return new _ObjectSchema(newShape);
+  }
+  pick(keys) {
+    const newShape = {};
+    for (const key of keys) {
+      const strKey = key;
+      if (Object.prototype.hasOwnProperty.call(this.shape, strKey)) {
+        newShape[strKey] = this.shape[strKey];
+      }
+    }
+    return new _ObjectSchema(newShape);
+  }
+  omit(keys) {
+    const newShape = {};
+    for (const key in this.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.shape, key) && !keys.includes(key)) {
+        newShape[key] = this.shape[key];
+      }
+    }
+    return new _ObjectSchema(newShape);
+  }
+  extend(shape) {
+    return new _ObjectSchema({ ...this.shape, ...shape });
+  }
+  merge(other) {
+    return new _ObjectSchema({ ...this.shape, ...other.shape });
+  }
+  _parse(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new SchemaError(msg("type_object"));
+    }
+    const obj = value;
+    const result = {};
+    for (const key in this.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.shape, key)) {
+        const schema = this.shape[key];
+        try {
+          result[key] = schema._parse(obj[key]);
+        } catch (e) {
+          if (e instanceof SchemaError) {
+            throw new SchemaError(e.message, {
+              path: e.path ? `${key}.${e.path}` : key,
+              received: obj[key]
+            });
+          }
+          throw e;
+        }
+      }
+    }
+    if (this.isStrictMode) {
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && !(key in this.shape)) {
+          throw new SchemaError(msg("object_strict", { key }));
+        }
+      }
+    }
+    if (this.isPassthroughMode) {
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && !(key in this.shape)) {
+          result[key] = obj[key];
+        }
+      }
+    }
+    return result;
+  }
+};
+var ArraySchema = class extends Schema {
+  constructor(itemSchema) {
+    super();
+    this.itemSchema = itemSchema;
+  }
+  itemSchema;
+  checks = [];
+  min(n) {
+    this.checks.push((val) => {
+      if (val.length < n) throw new SchemaError(msg("array_min", { min: n }));
+    });
+    return this;
+  }
+  max(n) {
+    this.checks.push((val) => {
+      if (val.length > n) throw new SchemaError(msg("array_max", { max: n }));
+    });
+    return this;
+  }
+  length(n) {
+    this.checks.push((val) => {
+      if (val.length !== n) throw new SchemaError(msg("array_length", { length: n }));
+    });
+    return this;
+  }
+  nonempty() {
+    this.checks.push((val) => {
+      if (val.length === 0) throw new SchemaError(msg("array_nonempty"));
+    });
+    return this;
+  }
+  unique() {
+    this.checks.push((val) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of val) {
+        if (seen.has(item)) throw new SchemaError(msg("array_unique"));
+        seen.add(item);
+      }
+    });
+    return this;
+  }
+  _parse(value) {
+    if (!Array.isArray(value)) throw new SchemaError(msg("type_array"));
+    const result = [];
+    for (let i = 0; i < value.length; i++) {
+      try {
+        result.push(this.itemSchema._parse(value[i]));
+      } catch (e) {
+        if (e instanceof SchemaError) {
+          throw new SchemaError(e.message, {
+            path: e.path ? `[${i}].${e.path}` : `[${i}]`,
+            received: value[i]
+          });
+        }
+        throw e;
+      }
+    }
+    for (const check of this.checks) check(result);
+    return result;
+  }
+};
+var TupleSchema = class extends Schema {
+  constructor(schemas) {
+    super();
+    this.schemas = schemas;
+  }
+  schemas;
+  _parse(value) {
+    if (!Array.isArray(value)) throw new SchemaError(msg("type_array"));
+    if (value.length !== this.schemas.length) {
+      throw new SchemaError(msg("tuple_length", { length: this.schemas.length }));
+    }
+    const result = [];
+    for (let i = 0; i < this.schemas.length; i++) {
+      try {
+        result.push(this.schemas[i]._parse(value[i]));
+      } catch (e) {
+        if (e instanceof SchemaError) {
+          throw new SchemaError(e.message, {
+            path: e.path ? `[${i}].${e.path}` : `[${i}]`,
+            received: value[i]
+          });
+        }
+        throw e;
+      }
+    }
+    return result;
+  }
+};
+var EnumSchema = class extends Schema {
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  values;
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    for (const v of this.values) {
+      if (v === value) return value;
+    }
+    throw new SchemaError(msg("enum_invalid", { values: this.values.join(", ") }));
+  }
+  get enum() {
+    return this.values;
+  }
+};
+var UnionSchema = class extends Schema {
+  constructor(schemas) {
+    super();
+    this.schemas = schemas;
+  }
+  schemas;
+  _parse(value) {
+    const errors = [];
+    for (const schema of this.schemas) {
+      try {
+        return schema._parse(value);
+      } catch (e) {
+        errors.push(e instanceof SchemaError ? e.message : String(e));
+      }
+    }
+    throw new SchemaError(msg("union_fail"));
+  }
+};
+var IntersectionSchema = class extends Schema {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  left;
+  right;
+  _parse(value) {
+    const a = this.left._parse(value);
+    const b = this.right._parse(value);
+    if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
+      return { ...a, ...b };
+    }
+    if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+      if (a === b) return a;
+    }
+    throw new SchemaError(msg("intersection_fail"));
+  }
+};
+var RecordSchema = class extends Schema {
+  constructor(valueSchema) {
+    super();
+    this.valueSchema = valueSchema;
+  }
+  valueSchema;
+  _parse(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new SchemaError(msg("type_object"));
+    }
+    const result = {};
+    const obj = value;
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        result[key] = this.valueSchema._parse(obj[key]);
+      }
+    }
+    return result;
+  }
+};
+var MapSchema = class extends Schema {
+  constructor(keySchema, valueSchema) {
+    super();
+    this.keySchema = keySchema;
+    this.valueSchema = valueSchema;
+  }
+  keySchema;
+  valueSchema;
+  _parse(value) {
+    if (!(value instanceof Map)) throw new SchemaError(msg("map_not_map"));
+    const result = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) {
+      result.set(this.keySchema._parse(k), this.valueSchema._parse(v));
+    }
+    return result;
+  }
+};
+var SetSchema = class extends Schema {
+  constructor(itemSchema) {
+    super();
+    this.itemSchema = itemSchema;
+  }
+  itemSchema;
+  _parse(value) {
+    if (!(value instanceof Set)) throw new SchemaError(msg("set_not_set"));
+    const result = /* @__PURE__ */ new Set();
+    for (const item of value) {
+      result.add(this.itemSchema._parse(item));
+    }
+    return result;
+  }
+};
+var DateSchema = class extends Schema {
+  _parse(value) {
+    if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) throw new SchemaError(msg("date_invalid"));
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "string") {
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) throw new SchemaError(msg("date_invalid"));
+      return date;
+    }
+    throw new SchemaError(msg("type_date"));
+  }
+};
+var LiteralSchema = class extends Schema {
+  constructor(expected) {
+    super();
+    this.expected = expected;
+  }
+  expected;
+  _parse(value) {
+    if (value !== this.expected) {
+      throw new SchemaError(msg("literal_fail", { expected: String(this.expected) }));
+    }
+    return value;
+  }
+};
+var AnySchema = class extends Schema {
+  _parse(value) {
+    return value;
+  }
+};
+var UnknownSchema = class extends Schema {
+  _parse(value) {
+    return value;
+  }
+};
+
+// src/schema/indonesia.ts
+function isNIK(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 16) return false;
+  const rawDay = Number.parseInt(digits.slice(6, 8), 10);
+  const month = Number.parseInt(digits.slice(8, 10), 10);
+  const year = Number.parseInt(digits.slice(10, 12), 10);
+  if (rawDay < 1 || rawDay > 71) return false;
+  if (month < 1 || month > 12) return false;
+  let day = rawDay;
+  if (day >= 41) day -= 40;
+  const fullYear = year < 70 ? 2e3 + year : 1900 + year;
+  const date = new Date(fullYear, month - 1, day);
+  return date.getFullYear() === fullYear && date.getMonth() === month - 1 && date.getDate() === day;
+}
+function isNPWP(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 15 && digits.length !== 16) return false;
+  const nums = [];
+  for (let i = 0; i < digits.length; i++) {
+    nums.push(Number.parseInt(digits[i], 10));
+  }
+  const checkDigit = nums[nums.length - 1];
+  let sum = 0;
+  for (let i = 0; i < nums.length - 1; i++) {
+    sum += nums[i] * [3, 7, 1][i % 3];
+  }
+  const computed = (11 - sum % 11) % 10;
+  return computed === checkDigit;
+}
+var INDONESIAN_PREFIXES = [
+  [11, 19],
+  [21, 29],
+  [51, 59],
+  [77, 79],
+  [95, 99]
+];
+function isValidIndonesianPrefix(prefix) {
+  for (const [min, max] of INDONESIAN_PREFIXES) {
+    if (prefix >= min && prefix <= max) return true;
+  }
+  return false;
+}
+function isPhone(value, country = "id") {
+  const digits = value.replace(/\D/g, "");
+  if (country === "any") {
+    return digits.length >= 10 && digits.length <= 15;
+  }
+  if (digits.length < 10) return false;
+  let normalized;
+  if (digits.startsWith("62")) {
+    normalized = digits.slice(2);
+  } else if (digits.startsWith("0")) {
+    normalized = digits.slice(1);
+  } else {
+    normalized = digits;
+  }
+  if (normalized.length < 10 || normalized.length > 13) return false;
+  if (!normalized.startsWith("8")) return false;
+  const prefix = Number.parseInt(normalized.slice(1, 3), 10);
+  return isValidIndonesianPrefix(prefix);
+}
+var NIKSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    if (!isNIK(value)) throw new SchemaError(msg("indonesia_nik"));
+    return value;
+  }
+};
+var NPWPSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    if (!isNPWP(value)) throw new SchemaError(msg("indonesia_npwp"));
+    return value;
+  }
+};
+var PhoneSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    if (!isPhone(value, "id")) throw new SchemaError(msg("indonesia_phone"));
+    return value;
+  }
+};
+var ALAMAT_KEYWORDS = [
+  /^jl[.\s]/i,
+  /^jalan\s/i,
+  /^gg[.\s]/i,
+  /^gang\s/i,
+  /rt\s*\d/i,
+  /rw\s*\d/i,
+  /dsn/i,
+  /dusun/i,
+  /kec/i,
+  /kelurahan/i,
+  /desa/i,
+  /perum/i,
+  /komplek/i
+];
+var AlamatSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    if (value.length < 10) throw new SchemaError(msg("indonesia_alamat"));
+    let hasKeyword = false;
+    for (const pattern of ALAMAT_KEYWORDS) {
+      if (pattern.test(value)) {
+        hasKeyword = true;
+        break;
+      }
+    }
+    if (!hasKeyword) throw new SchemaError(msg("indonesia_alamat"));
+    return value;
+  }
+};
+var KodeposSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    const digits = value.replace(/\s/g, "");
+    if (!/^\d{5}$/.test(digits)) throw new SchemaError(msg("indonesia_kodepos"));
+    return digits;
+  }
+};
+var RekeningSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value !== "string") throw new SchemaError(msg("type_string"));
+    const digits = value.replace(/\s/g, "");
+    if (!/^\d{10,16}$/.test(digits)) throw new SchemaError(msg("indonesia_rekening"));
+    return digits;
+  }
+};
+
+// src/schema/transform.ts
+var CoerceStringSchema = class extends Schema {
+  _parse(value) {
+    if (value === null || value === void 0) throw new SchemaError(msg("type_string"));
+    return String(value);
+  }
+};
+var CoerceNumberSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.length === 0) throw new SchemaError(msg("coerce_number_fail"));
+      const num = Number(trimmed);
+      if (Number.isNaN(num)) throw new SchemaError(msg("coerce_number_fail"));
+      return num;
+    }
+    if (typeof value === "bigint") return Number(value);
+    if (value instanceof Date) return value.getTime();
+    throw new SchemaError(msg("coerce_number_fail"));
+  }
+};
+var CoerceBooleanSchema = class extends Schema {
+  _parse(value) {
+    if (typeof value === "boolean") return value;
+    if (value === 0 || value === 1) return value === 1;
+    if (typeof value === "string") {
+      const lower = value.toLowerCase().trim();
+      if (lower === "true" || lower === "1" || lower === "yes" || lower === "on") return true;
+      if (lower === "false" || lower === "0" || lower === "no" || lower === "off") return false;
+    }
+    return Boolean(value);
+  }
+};
+var CoerceDateSchema = class extends Schema {
+  _parse(value) {
+    if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) throw new SchemaError(msg("coerce_date_fail"));
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "string") {
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) throw new SchemaError(msg("coerce_date_fail"));
+      return date;
+    }
+    throw new SchemaError(msg("coerce_date_fail"));
+  }
+};
+var StandaloneTransformSchema = class extends Schema {
+  constructor(fn) {
+    super();
+    this.fn = fn;
+  }
+  fn;
+  _parse(value) {
+    return this.fn(value);
+  }
+};
+
+// src/schema/index.ts
+var s = {
+  string() {
+    return new StringSchema();
+  },
+  number() {
+    return new NumberSchema();
+  },
+  boolean() {
+    return new BooleanSchema();
+  },
+  bigint() {
+    return new BigIntSchema();
+  },
+  symbol() {
+    return new SymbolSchema();
+  },
+  undefined() {
+    return new UndefinedSchema();
+  },
+  null() {
+    return new NullSchema();
+  },
+  nan() {
+    return new NaNSchema();
+  },
+  object(shape) {
+    return new ObjectSchema(shape);
+  },
+  array(itemSchema) {
+    return new ArraySchema(itemSchema);
+  },
+  tuple(...schemas) {
+    return new TupleSchema(schemas);
+  },
+  enum(values) {
+    return new EnumSchema(values);
+  },
+  union(...schemas) {
+    return new UnionSchema(schemas);
+  },
+  intersection(left, right) {
+    return new IntersectionSchema(left, right);
+  },
+  record(valueSchema) {
+    return new RecordSchema(valueSchema);
+  },
+  map(keySchema, valueSchema) {
+    return new MapSchema(keySchema, valueSchema);
+  },
+  set(itemSchema) {
+    return new SetSchema(itemSchema);
+  },
+  date() {
+    return new DateSchema();
+  },
+  literal(value) {
+    return new LiteralSchema(value);
+  },
+  any() {
+    return new AnySchema();
+  },
+  unknown() {
+    return new UnknownSchema();
+  },
+  // ─── Indonesia ──────────────────────────────────────────
+  nik() {
+    return new NIKSchema();
+  },
+  npwp() {
+    return new NPWPSchema();
+  },
+  phone() {
+    return new PhoneSchema();
+  },
+  alamat() {
+    return new AlamatSchema();
+  },
+  kodepos() {
+    return new KodeposSchema();
+  },
+  rekening() {
+    return new RekeningSchema();
+  },
+  // ─── Coerce ─────────────────────────────────────────────
+  coerce: {
+    string() {
+      return new CoerceStringSchema();
+    },
+    number() {
+      return new CoerceNumberSchema();
+    },
+    boolean() {
+      return new CoerceBooleanSchema();
+    },
+    date() {
+      return new CoerceDateSchema();
+    }
+  },
+  // ─── Transform ──────────────────────────────────────────
+  transform(fn) {
+    return new StandaloneTransformSchema(fn);
+  }
+};
+export {
+  AlamatSchema,
+  AnySchema,
+  ArraySchema,
+  BigIntSchema,
+  BooleanSchema,
+  CoerceBooleanSchema,
+  CoerceDateSchema,
+  CoerceNumberSchema,
+  CoerceStringSchema,
+  DateSchema,
+  EnumSchema,
+  IntersectionSchema,
+  KodeposSchema,
+  LiteralSchema,
+  MapSchema,
+  NIKSchema,
+  NPWPSchema,
+  NaNSchema,
+  NullSchema,
+  NumberSchema,
+  ObjectSchema,
+  PhoneSchema,
+  RecordSchema,
+  RekeningSchema,
+  Schema,
+  SchemaError,
+  SetSchema,
+  StringSchema,
+  SymbolSchema,
+  TupleSchema,
+  UndefinedSchema,
+  UnionSchema,
+  UnknownSchema,
+  getLocale,
+  s,
+  setLocale
+};
+//# sourceMappingURL=index.js.map