@asterdoc/format 0.0.0-stage → 0.9.0

package/dist/index.js

@@ -0,0 +1,2136 @@
+// src/cache.ts
+var DEFAULT_CACHE_SIZE = 64;
+var MAX_CACHE_SIZE = 256;
+var BoundedCache = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  entries = /* @__PURE__ */ new Map();
+  hitCount = 0;
+  missCount = 0;
+  get(key) {
+    const value = this.entries.get(key);
+    if (value === void 0) {
+      this.missCount += 1;
+      return void 0;
+    }
+    this.hitCount += 1;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    while (this.entries.size > this.limit) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === void 0) break;
+      this.entries.delete(oldest);
+    }
+  }
+  snapshot() {
+    return {
+      size: this.entries.size,
+      hits: this.hitCount,
+      misses: this.missCount,
+      limit: this.limit
+    };
+  }
+};
+function stableSerialize(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableSerialize).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`).join(",")}}`;
+}
+
+// src/messages.ts
+var MissingMessageError = class extends Error {
+  constructor(key, locale) {
+    super(`No formatter message ${JSON.stringify(key)} is available for locale ${JSON.stringify(locale)}.`);
+    this.key = key;
+    this.locale = locale;
+    this.name = "MissingMessageError";
+  }
+  key;
+  locale;
+};
+function findMessage(messages, locale, key) {
+  const exact = messages[locale]?.[key];
+  if (exact !== void 0) return exact;
+  const language = locale.split("-")[0];
+  const languageMessages = Object.entries(messages).find(([candidate]) => candidate.split("-")[0] === language)?.[1];
+  return languageMessages?.[key];
+}
+function resolveMessage(context, key) {
+  const message = findMessage(context.messages, context.locale, key);
+  if (message !== void 0) return message;
+  if (context.fallbackLocale !== void 0) {
+    const fallbackMessage = findMessage(context.messages, context.fallbackLocale, key);
+    if (fallbackMessage !== void 0) return fallbackMessage;
+  }
+  throw new MissingMessageError(key, context.locale);
+}
+
+// src/shared.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissing(value) {
+  return value === null || value === void 0;
+}
+function issue(kind, code, message, path, cause) {
+  return { code, message, kind, ...path === void 0 ? {} : { path }, ...cause === void 0 ? {} : { cause } };
+}
+function statusForIssues(issues) {
+  return issues.some((item) => item.code.startsWith("invalid")) ? "invalid" : "incomplete";
+}
+
+// src/contacts.ts
+var UnsupportedAddressLayoutError = class extends Error {
+  country;
+  constructor(country) {
+    super(`No country-specific address layout is available for ${JSON.stringify(country)}.`);
+    this.name = "UnsupportedAddressLayoutError";
+    this.country = country;
+  }
+};
+var COUNTRY_ALIASES = {
+  US: "US",
+  USA: "US",
+  "UNITED STATES": "US",
+  "UNITED STATES OF AMERICA": "US",
+  GB: "GB",
+  UK: "GB",
+  "UNITED KINGDOM": "GB",
+  "GREAT BRITAIN": "GB",
+  DE: "DE",
+  GERMANY: "DE",
+  DEUTSCHLAND: "DE",
+  FR: "FR",
+  FRANCE: "FR",
+  SA: "SA",
+  "SAUDI ARABIA": "SA"
+};
+var ORG_KEYS = /* @__PURE__ */ new Set(["legalName", "domicile", "entityType", "entityId", "taxId"]);
+var PERSON_KEYS = /* @__PURE__ */ new Set(["title", "firstName", "middleName", "lastName", "suffix"]);
+var BUILT_IN_CONTACT_MESSAGES = {
+  "en-US": {
+    "phone.extension": "ext.",
+    "organization.legalName": "Legal name",
+    "organization.entityType": "Entity type",
+    "organization.entityId": "Entity ID",
+    "organization.taxId": "Tax ID",
+    "organization.domicile": "Domicile"
+  },
+  "en-GB": {
+    "phone.extension": "ext.",
+    "organization.legalName": "Legal name",
+    "organization.entityType": "Entity type",
+    "organization.entityId": "Entity ID",
+    "organization.taxId": "Tax ID",
+    "organization.domicile": "Domicile"
+  },
+  "de-DE": {
+    "phone.extension": "Durchwahl",
+    "organization.legalName": "Rechtlicher Name",
+    "organization.entityType": "Rechtsform",
+    "organization.entityId": "Unternehmens-ID",
+    "organization.taxId": "Steuer-ID",
+    "organization.domicile": "Sitz"
+  },
+  "fr-FR": {
+    "phone.extension": "poste",
+    "organization.legalName": "Nom l\xE9gal",
+    "organization.entityType": "Forme juridique",
+    "organization.entityId": "ID de l'entreprise",
+    "organization.taxId": "N\xB0 fiscal",
+    "organization.domicile": "Domicile"
+  },
+  "ar-SA": {
+    "phone.extension": "\u062A\u062D\u0648\u064A\u0644\u0629",
+    "organization.legalName": "\u0627\u0644\u0627\u0633\u0645 \u0627\u0644\u0642\u0627\u0646\u0648\u0646\u064A",
+    "organization.entityType": "\u0646\u0648\u0639 \u0627\u0644\u0643\u064A\u0627\u0646",
+    "organization.entityId": "\u0645\u0639\u0631\u0651\u0641 \u0627\u0644\u0643\u064A\u0627\u0646",
+    "organization.taxId": "\u0627\u0644\u0631\u0642\u0645 \u0627\u0644\u0636\u0631\u064A\u0628\u064A",
+    "organization.domicile": "\u0627\u0644\u0645\u0648\u0637\u0646"
+  }
+};
+function stringMember(kind, object, key, issues, options) {
+  const value = object[key];
+  if (isMissing(value)) {
+    if (options.required) issues.push(issue(kind, "missing_member", `${key} is required.`, key));
+    return void 0;
+  }
+  const minLength = options.minLength ?? 1;
+  if (typeof value !== "string" || value.trim().length < minLength || value.length > options.maxLength) {
+    issues.push(issue(kind, "invalid_member", `${key} must be a string of ${minLength} to ${options.maxLength} characters.`, key));
+    return void 0;
+  }
+  return value;
+}
+function normalizeCountry(value) {
+  const normalized = value.trim().toUpperCase();
+  return COUNTRY_ALIASES[normalized] ?? (/^[A-Z]{2}$/.test(normalized) ? normalized : void 0);
+}
+function validateAddress(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("address", "missing_value", "Address value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("address", "invalid_object", "Address value must be an object.")] };
+  }
+  const issues = [];
+  const line1 = stringMember("address", value, "line1", issues, { required: true, maxLength: 200 });
+  const line2 = stringMember("address", value, "line2", issues, { maxLength: 200 });
+  const locality = stringMember("address", value, "locality", issues, { required: true, maxLength: 200 });
+  const region = stringMember("address", value, "region", issues, { required: true, maxLength: 100 });
+  const postalCode = stringMember("address", value, "postalCode", issues, { required: true, maxLength: 20 });
+  const country = stringMember("address", value, "country", issues, { required: true, minLength: 2, maxLength: 100 });
+  if (postalCode !== void 0 && !/^[A-Z0-9\s-]{3,20}$/.test(postalCode)) {
+    issues.push(issue("address", "invalid_member", "postalCode must contain only uppercase letters, numbers, spaces, or hyphens.", "postalCode"));
+  }
+  if (issues.length > 0) {
+    return { ok: false, status: statusForIssues(issues), issues };
+  }
+  return {
+    ok: true,
+    value: {
+      line1,
+      ...line2 === void 0 ? {} : { line2 },
+      locality,
+      region,
+      postalCode,
+      country,
+      countryCode: normalizeCountry(country)
+    }
+  };
+}
+function validatePhoneNumber(number, issues, path = "number") {
+  if (isMissing(number)) {
+    issues.push(issue("phone", "missing_member", "Phone number is required.", path));
+    return void 0;
+  }
+  if (typeof number !== "string" || !/^\+[1-9]\d{1,14}$/.test(number) || number.length < 8) {
+    issues.push(issue("phone", "invalid_member", "Phone number must use canonical E.164 syntax with at most 15 digits.", path));
+    return void 0;
+  }
+  return number;
+}
+function validatePhone(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("phone", "missing_value", "Phone value is missing.")] };
+  }
+  if (typeof value === "string") {
+    const issues2 = [];
+    const number2 = validatePhoneNumber(value, issues2, "number");
+    return issues2.length > 0 ? { ok: false, status: "invalid", issues: issues2 } : { ok: true, value: { number: number2 } };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("phone", "invalid_object", "Phone value must be an E.164 string or object.")] };
+  }
+  const issues = [];
+  const number = validatePhoneNumber(value.number, issues);
+  let type;
+  if (!isMissing(value.type)) {
+    if (typeof value.type !== "string" || value.type.trim().length === 0 || value.type.length > 50) {
+      issues.push(issue("phone", "invalid_member", "Phone type must be a non-empty string of at most 50 characters.", "type"));
+    } else {
+      type = value.type;
+    }
+  }
+  let extension;
+  if (!isMissing(value.extension)) {
+    if (typeof value.extension !== "string" || value.extension.length < 1 || value.extension.length > 20) {
+      issues.push(issue("phone", "invalid_member", "Phone extension must be a non-empty string of at most 20 characters.", "extension"));
+    } else {
+      extension = value.extension;
+    }
+  }
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return {
+    ok: true,
+    value: {
+      number,
+      ...type === void 0 ? {} : { type },
+      ...extension === void 0 ? {} : { extension }
+    }
+  };
+}
+function validatePerson(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("person", "missing_value", "Person value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("person", "invalid_object", "Person value must be an object.")] };
+  }
+  const issues = [];
+  const name = stringMember("person", value, "name", issues, { maxLength: 200 });
+  const title = stringMember("person", value, "title", issues, { maxLength: 50 });
+  const firstName = stringMember("person", value, "firstName", issues, { maxLength: 100 });
+  const middleName = stringMember("person", value, "middleName", issues, { maxLength: 100 });
+  const lastName = stringMember("person", value, "lastName", issues, { maxLength: 100 });
+  const suffix = stringMember("person", value, "suffix", issues, { maxLength: 50 });
+  const hasName = name !== void 0 || [title, firstName, middleName, lastName, suffix].some((part) => part !== void 0);
+  if (!hasName && issues.length === 0) {
+    issues.push(issue("person", "missing_member", "Person requires a name or at least one name component."));
+  }
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return { ok: true, value };
+}
+function validateOrganization(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("organization", "missing_value", "Organization value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("organization", "invalid_object", "Organization value must be an object.")] };
+  }
+  const issues = [];
+  const name = stringMember("organization", value, "name", issues, { required: true, maxLength: 200 });
+  const legalName = stringMember("organization", value, "legalName", issues, { maxLength: 200 });
+  const domicile = stringMember("organization", value, "domicile", issues, { maxLength: 100 });
+  const entityType = stringMember("organization", value, "entityType", issues, { maxLength: 100 });
+  const entityId = stringMember("organization", value, "entityId", issues, { maxLength: 100 });
+  const taxId = stringMember("organization", value, "taxId", issues, { maxLength: 100 });
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return { ok: true, value: { name, ...legalName === void 0 ? {} : { legalName }, ...domicile === void 0 ? {} : { domicile }, ...entityType === void 0 ? {} : { entityType }, ...entityId === void 0 ? {} : { entityId }, ...taxId === void 0 ? {} : { taxId } } };
+}
+function inferPartyIdentity(value, options) {
+  if (options.partyType !== void 0) return options.partyType;
+  const hasOrganizationIdentity = [...ORG_KEYS].some((key) => !isMissing(value[key]));
+  const hasPersonIdentity = [...PERSON_KEYS].some((key) => !isMissing(value[key]));
+  if (hasOrganizationIdentity && hasPersonIdentity) return "ambiguous";
+  if (hasOrganizationIdentity) return "organization";
+  if (hasPersonIdentity) return "person";
+  return void 0;
+}
+function validateParty(value, options) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("party", "missing_value", "Party value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("party", "invalid_object", "Party value must be an object.")] };
+  }
+  const identity = inferPartyIdentity(value, options);
+  if (identity === void 0 || identity === "ambiguous") {
+    return { ok: false, status: "invalid", issues: [issue("party", "ambiguous_identity", "Party identity is ambiguous; supply a person or organization member or partyType option.")] };
+  }
+  const validation = identity === "person" ? validatePerson(value) : validateOrganization(value);
+  if (!validation.ok) {
+    return {
+      ok: false,
+      status: validation.status,
+      issues: validation.issues.map((item) => ({ ...item, kind: "party", path: item.path === void 0 ? identity : `${identity}.${item.path}` }))
+    };
+  }
+  return { ok: true, value: { value, identity } };
+}
+function formatAddress(address, options, context) {
+  const countryCode = address.countryCode;
+  if (options.layout === "generic") return genericAddress(address);
+  const custom = Object.entries(options.countryLayouts ?? {}).find(([country]) => country.toUpperCase() === countryCode)?.[1];
+  if (custom !== void 0) return custom(address, context);
+  if (countryCode === void 0 || COUNTRY_LAYOUTS[countryCode] === void 0) {
+    throw new UnsupportedAddressLayoutError(address.country);
+  }
+  return COUNTRY_LAYOUTS[countryCode](address, context);
+}
+function genericAddress(address) {
+  return [address.line1, address.line2, address.locality, address.region, address.postalCode, address.country].filter((part) => typeof part === "string" && part.length > 0).join(", ");
+}
+function countryAddress(parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(", ");
+}
+var COUNTRY_LAYOUTS = {
+  US: (address) => countryAddress([address.line1, address.line2, address.locality, `${address.region} ${address.postalCode}`, address.country]),
+  GB: (address) => countryAddress([address.line1, address.line2, address.locality, address.region, address.postalCode, address.country]),
+  DE: (address) => countryAddress([address.line1, address.line2, `${address.postalCode} ${address.locality}`, address.region, address.country]),
+  FR: (address) => countryAddress([address.line1, address.line2, `${address.postalCode} ${address.locality}`, address.region, address.country]),
+  SA: (address) => countryAddress([address.line1, address.line2, `${address.postalCode} ${address.locality}`, address.region, address.country])
+};
+function formatPhone(phone, options, context) {
+  if (phone.extension === void 0) return phone.number;
+  const label = options.extensionLabel ?? resolveMessage(context, "phone.extension");
+  return `${phone.number} ${label} ${phone.extension}`;
+}
+function formatPerson(person) {
+  const value = person;
+  if (typeof value.name === "string" && value.name.length > 0) return value.name;
+  return ["title", "firstName", "middleName", "lastName", "suffix"].map((key) => value[key]).filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+function formatOrganization(organization, context) {
+  const value = organization;
+  const details = [];
+  if (typeof value.legalName === "string" && value.legalName !== value.name) details.push(`${resolveMessage(context, "organization.legalName")}: ${value.legalName}`);
+  if (typeof value.entityType === "string") details.push(`${resolveMessage(context, "organization.entityType")}: ${value.entityType}`);
+  if (typeof value.entityId === "string") details.push(`${resolveMessage(context, "organization.entityId")}: ${value.entityId}`);
+  if (typeof value.taxId === "string") details.push(`${resolveMessage(context, "organization.taxId")}: ${value.taxId}`);
+  if (typeof value.domicile === "string") details.push(`${resolveMessage(context, "organization.domicile")}: ${value.domicile}`);
+  return details.length === 0 ? String(value.name) : `${String(value.name)} (${details.join(", ")})`;
+}
+function validateAddressOptions(options) {
+  if (options.layout !== void 0 && options.layout !== "country" && options.layout !== "generic") {
+    throw new Error('Address layout must be "country" or "generic".');
+  }
+  if (options.countryLayouts !== void 0) {
+    if (!isRecord(options.countryLayouts)) throw new Error("Address countryLayouts must be an object.");
+    for (const [country, formatter] of Object.entries(options.countryLayouts)) {
+      if (!/^[A-Z]{2}$/.test(country.toUpperCase()) || typeof formatter !== "function") {
+        throw new Error("Address countryLayouts keys must be ISO alpha-2 codes with function values.");
+      }
+    }
+  }
+}
+function validatePhoneOptions(options) {
+  if (options.extensionLabel !== void 0 && (typeof options.extensionLabel !== "string" || options.extensionLabel.trim().length === 0)) {
+    throw new Error("Phone extensionLabel must be a non-empty string.");
+  }
+}
+function validatePartyOptions(options) {
+  if (options.partyType !== void 0 && options.partyType !== "person" && options.partyType !== "organization") {
+    throw new Error('Party partyType must be "person" or "organization".');
+  }
+}
+function validateContactOptions(kind, options) {
+  if (kind === "address") validateAddressOptions(options);
+  if (kind === "phone") validatePhoneOptions(options);
+  if (kind === "party") validatePartyOptions(options);
+}
+
+// src/temporal.ts
+var BUILT_IN_TEMPORAL_MESSAGES = {
+  "en-US": {
+    "duration.year.one": "{value} year",
+    "duration.year.other": "{value} years",
+    "duration.month.one": "{value} month",
+    "duration.month.other": "{value} months",
+    "duration.week.one": "{value} week",
+    "duration.week.other": "{value} weeks",
+    "duration.day.one": "{value} day",
+    "duration.day.other": "{value} days",
+    "duration.hour.one": "{value} hour",
+    "duration.hour.other": "{value} hours",
+    "duration.minute.one": "{value} minute",
+    "duration.minute.other": "{value} minutes",
+    "duration.second.one": "{value} second",
+    "duration.second.other": "{value} seconds"
+  },
+  "en-GB": {
+    "duration.year.one": "{value} year",
+    "duration.year.other": "{value} years",
+    "duration.month.one": "{value} month",
+    "duration.month.other": "{value} months",
+    "duration.week.one": "{value} week",
+    "duration.week.other": "{value} weeks",
+    "duration.day.one": "{value} day",
+    "duration.day.other": "{value} days",
+    "duration.hour.one": "{value} hour",
+    "duration.hour.other": "{value} hours",
+    "duration.minute.one": "{value} minute",
+    "duration.minute.other": "{value} minutes",
+    "duration.second.one": "{value} second",
+    "duration.second.other": "{value} seconds"
+  },
+  "de-DE": {
+    "duration.year.one": "{value} Jahr",
+    "duration.year.other": "{value} Jahre",
+    "duration.month.one": "{value} Monat",
+    "duration.month.other": "{value} Monate",
+    "duration.week.one": "{value} Woche",
+    "duration.week.other": "{value} Wochen",
+    "duration.day.one": "{value} Tag",
+    "duration.day.other": "{value} Tage",
+    "duration.hour.one": "{value} Stunde",
+    "duration.hour.other": "{value} Stunden",
+    "duration.minute.one": "{value} Minute",
+    "duration.minute.other": "{value} Minuten",
+    "duration.second.one": "{value} Sekunde",
+    "duration.second.other": "{value} Sekunden"
+  },
+  "fr-FR": {
+    "duration.year.one": "{value} an",
+    "duration.year.other": "{value} ans",
+    "duration.month.one": "{value} mois",
+    "duration.month.other": "{value} mois",
+    "duration.week.one": "{value} semaine",
+    "duration.week.other": "{value} semaines",
+    "duration.day.one": "{value} jour",
+    "duration.day.other": "{value} jours",
+    "duration.hour.one": "{value} heure",
+    "duration.hour.other": "{value} heures",
+    "duration.minute.one": "{value} minute",
+    "duration.minute.other": "{value} minutes",
+    "duration.second.one": "{value} seconde",
+    "duration.second.other": "{value} secondes"
+  },
+  "ar-SA": {
+    "duration.year.one": "{value} \u0633\u0646\u0629",
+    "duration.year.two": "{value} \u0633\u0646\u062A\u0627\u0646",
+    "duration.year.few": "{value} \u0633\u0646\u0648\u0627\u062A",
+    "duration.year.many": "{value} \u0633\u0646\u0629",
+    "duration.year.other": "{value} \u0633\u0646\u0629",
+    "duration.month.one": "{value} \u0634\u0647\u0631",
+    "duration.month.two": "{value} \u0634\u0647\u0631\u0627\u0646",
+    "duration.month.few": "{value} \u0623\u0634\u0647\u0631",
+    "duration.month.many": "{value} \u0634\u0647\u0631",
+    "duration.month.other": "{value} \u0634\u0647\u0631",
+    "duration.week.one": "{value} \u0623\u0633\u0628\u0648\u0639",
+    "duration.week.two": "{value} \u0623\u0633\u0628\u0648\u0639\u0627\u0646",
+    "duration.week.few": "{value} \u0623\u0633\u0627\u0628\u064A\u0639",
+    "duration.week.many": "{value} \u0623\u0633\u0628\u0648\u0639",
+    "duration.week.other": "{value} \u0623\u0633\u0628\u0648\u0639",
+    "duration.day.one": "{value} \u064A\u0648\u0645",
+    "duration.day.two": "{value} \u064A\u0648\u0645\u0627\u0646",
+    "duration.day.few": "{value} \u0623\u064A\u0627\u0645",
+    "duration.day.many": "{value} \u064A\u0648\u0645",
+    "duration.day.other": "{value} \u064A\u0648\u0645",
+    "duration.hour.one": "{value} \u0633\u0627\u0639\u0629",
+    "duration.hour.two": "{value} \u0633\u0627\u0639\u062A\u0627\u0646",
+    "duration.hour.few": "{value} \u0633\u0627\u0639\u0627\u062A",
+    "duration.hour.many": "{value} \u0633\u0627\u0639\u0629",
+    "duration.hour.other": "{value} \u0633\u0627\u0639\u0629",
+    "duration.minute.one": "{value} \u062F\u0642\u064A\u0642\u0629",
+    "duration.minute.two": "{value} \u062F\u0642\u064A\u0642\u062A\u0627\u0646",
+    "duration.minute.few": "{value} \u062F\u0642\u0627\u0626\u0642",
+    "duration.minute.many": "{value} \u062F\u0642\u064A\u0642\u0629",
+    "duration.minute.other": "{value} \u062F\u0642\u064A\u0642\u0629",
+    "duration.second.one": "{value} \u062B\u0627\u0646\u064A\u0629",
+    "duration.second.two": "{value} \u062B\u0627\u0646\u064A\u062A\u0627\u0646",
+    "duration.second.few": "{value} \u062B\u0648\u0627\u0646\u064D",
+    "duration.second.many": "{value} \u062B\u0627\u0646\u064A\u0629",
+    "duration.second.other": "{value} \u062B\u0627\u0646\u064A\u0629"
+  }
+};
+var DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+var DATETIME_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}:?\d{2})?$/;
+var TIME_PATTERN = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/;
+var DURATION_PATTERN = /^P(?=\d|T\d)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(?:T(?=\d)(\d+H)?(\d+M)?(\d+(?:\.\d+)?S)?)?$/;
+function missing(kind) {
+  return { ok: false, status: "missing", issues: [issue(kind, "missing_value", `${kind} value is missing.`)] };
+}
+function invalid(kind, message, path, code = "invalid_value") {
+  return { ok: false, status: "invalid", issues: [issue(kind, code, message, path)] };
+}
+function daysInMonth(year, month) {
+  if (month === 2) {
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    return leap ? 29 : 28;
+  }
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function validDateParts(year, month, day) {
+  return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
+}
+function makeUtcDate(year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0) {
+  const result = /* @__PURE__ */ new Date(0);
+  result.setUTCFullYear(year, month - 1, day);
+  result.setUTCHours(hour, minute, second, millisecond);
+  return result;
+}
+function parseOffset(value) {
+  if (value === void 0) return void 0;
+  if (value === "Z") return 0;
+  const match = /^([+-])(\d{2}):?(\d{2})$/.exec(value);
+  if (match === null) return void 0;
+  const hours = Number(match[2]);
+  const minutes = Number(match[3]);
+  if (minutes > 59 || hours > 23) return void 0;
+  const total = hours * 60 + minutes;
+  return match[1] === "-" ? -total : total;
+}
+function parseDateTimeString(value) {
+  const match = DATETIME_PATTERN.exec(value);
+  if (match === null) return void 0;
+  const offsetMinutes = parseOffset(match[8]);
+  if (match[8] !== void 0 && offsetMinutes === void 0) return void 0;
+  const fraction = match[7] ?? "";
+  return {
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3]),
+    hour: Number(match[4]),
+    minute: Number(match[5]),
+    second: Number(match[6] ?? 0),
+    millisecond: Number((fraction + "000").slice(0, 3)),
+    offsetMinutes
+  };
+}
+function hasInvalidOffset(value) {
+  const match = DATETIME_PATTERN.exec(value);
+  return match !== null && match[8] !== void 0 && parseOffset(match[8]) === void 0;
+}
+function validClock(hour, minute, second) {
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+}
+function makeInstant(parts) {
+  return new Date(makeUtcDate(
+    parts.year,
+    parts.month,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+    parts.millisecond
+  ).getTime() - parts.offsetMinutes * 6e4);
+}
+function validateDate(value) {
+  if (value === null || value === void 0) return missing("date");
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? invalid("date", "Date object is invalid.") : { ok: true, value: { date: value, mode: "instant" } };
+  }
+  if (typeof value !== "string" || value.length === 0) return invalid("date", "Date must be an ISO date, datetime, or valid Date object.");
+  const dateMatch = DATE_PATTERN.exec(value);
+  if (dateMatch !== null) {
+    const year = Number(dateMatch[1]);
+    const month = Number(dateMatch[2]);
+    const day = Number(dateMatch[3]);
+    return validDateParts(year, month, day) ? { ok: true, value: { date: makeUtcDate(year, month, day), mode: "calendar" } } : invalid("date", `Date ${JSON.stringify(value)} names an impossible calendar day.`);
+  }
+  const parts = parseDateTimeString(value);
+  if (hasInvalidOffset(value)) return invalid("date", `Datetime offset in ${JSON.stringify(value)} is invalid.`, "offset", "invalid_offset");
+  if (parts === void 0 || !validDateParts(parts.year, parts.month, parts.day) || !validClock(parts.hour, parts.minute, parts.second)) {
+    return invalid("date", `Date ${JSON.stringify(value)} is not a valid ISO calendar value.`);
+  }
+  const date = parts.offsetMinutes === void 0 ? makeUtcDate(parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second, parts.millisecond) : makeInstant({ ...parts, offsetMinutes: parts.offsetMinutes });
+  return { ok: true, value: { date, mode: parts.offsetMinutes === void 0 ? "local" : "instant" } };
+}
+function validateDatetime(value) {
+  if (value === null || value === void 0) return missing("datetime");
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? invalid("datetime", "Date object is invalid.") : { ok: true, value: { date: value, mode: "instant" } };
+  }
+  if (typeof value !== "string" || value.length === 0) return invalid("datetime", "Datetime must be an ISO datetime string or valid Date object.");
+  const parts = parseDateTimeString(value);
+  if (hasInvalidOffset(value)) return invalid("datetime", `Datetime offset in ${JSON.stringify(value)} is invalid.`, "offset", "invalid_offset");
+  if (parts === void 0 || !validDateParts(parts.year, parts.month, parts.day) || !validClock(parts.hour, parts.minute, parts.second)) {
+    return invalid("datetime", `Datetime ${JSON.stringify(value)} is not a valid ISO datetime value.`);
+  }
+  const date = parts.offsetMinutes === void 0 ? makeUtcDate(parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second, parts.millisecond) : makeInstant({ ...parts, offsetMinutes: parts.offsetMinutes });
+  return { ok: true, value: { date, mode: parts.offsetMinutes === void 0 ? "local" : "instant" } };
+}
+function validateTime(value) {
+  if (value === null || value === void 0) return missing("time");
+  if (typeof value !== "string" || value.length === 0) return invalid("time", "Time must be an ISO time string.");
+  const match = TIME_PATTERN.exec(value);
+  if (match === null) return invalid("time", `Time ${JSON.stringify(value)} is not a valid 24-hour clock value.`);
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3] ?? 0);
+  if (!validClock(hour, minute, second)) return invalid("time", `Time ${JSON.stringify(value)} is not a valid 24-hour clock value.`);
+  return {
+    ok: true,
+    value: {
+      date: makeUtcDate(1970, 1, 1, hour, minute, second, Number(((match[4] ?? "") + "000").slice(0, 3)))
+    }
+  };
+}
+function validateDuration(value) {
+  if (value === null || value === void 0) return missing("duration");
+  if (typeof value !== "string" || value.length === 0) return invalid("duration", "Duration must be an ISO 8601 duration string.");
+  const match = DURATION_PATTERN.exec(value);
+  if (match === null) return invalid("duration", `Duration ${JSON.stringify(value)} is not a valid ISO 8601 duration.`);
+  const parsed = {
+    years: Number.parseInt(match[1]?.slice(0, -1) ?? "0", 10),
+    months: Number.parseInt(match[2]?.slice(0, -1) ?? "0", 10),
+    weeks: Number.parseInt(match[3]?.slice(0, -1) ?? "0", 10),
+    days: Number.parseInt(match[4]?.slice(0, -1) ?? "0", 10),
+    hours: Number.parseInt(match[5]?.slice(0, -1) ?? "0", 10),
+    minutes: Number.parseInt(match[6]?.slice(0, -1) ?? "0", 10),
+    seconds: Number.parseFloat(match[7]?.slice(0, -1) ?? "0")
+  };
+  for (const [component, amount] of Object.entries(parsed)) {
+    if (!Number.isFinite(amount)) {
+      return invalid("duration", `Duration ${JSON.stringify(value)} contains an out-of-range ${component} component.`, component, "invalid_number");
+    }
+  }
+  return {
+    ok: true,
+    value: parsed
+  };
+}
+function formatDurationValue(value, options, context) {
+  const parts = [];
+  const units = [
+    ["years", "year"],
+    ["months", "month"],
+    ["weeks", "week"],
+    ["days", "day"],
+    ["hours", "hour"],
+    ["minutes", "minute"],
+    ["seconds", "second"]
+  ];
+  const numberFormat = context.numberFormat({
+    maximumFractionDigits: 9,
+    ...options
+  });
+  const pluralRules = context.pluralRules(numberFormat.resolvedOptions());
+  for (const [key, unit] of units) {
+    const amount = value[key];
+    if (amount === 0) continue;
+    const category = pluralRules.select(amount);
+    const template = resolveMessage(context, `duration.${unit}.${category}`);
+    const number = numberFormat.format(amount);
+    parts.push(template.includes("{value}") ? template.replaceAll("{value}", number) : `${number} ${template}`);
+  }
+  if (parts.length === 0) {
+    const template = resolveMessage(context, "duration.second.other");
+    const number = numberFormat.format(0);
+    return template.includes("{value}") ? template.replaceAll("{value}", number) : `${number} ${template}`;
+  }
+  return parts.length === 1 ? parts[0] : context.listFormat().format(parts);
+}
+function dateTimeDefaults(kind, options) {
+  const raw = options;
+  if (raw.dateStyle !== void 0 || raw.timeStyle !== void 0) return raw;
+  const hasDateFields = ["weekday", "year", "month", "day", "dateStyle"].some((key) => raw[key] !== void 0);
+  const hasTimeFields = ["dayPeriod", "hour", "minute", "second", "timeStyle"].some((key) => raw[key] !== void 0);
+  const hasFractionalSecondDigits = raw.fractionalSecondDigits !== void 0;
+  const secondsForFraction = hasFractionalSecondDigits && raw.second === void 0 && raw.timeStyle === void 0 ? { second: "2-digit" } : {};
+  if (kind === "date") {
+    return hasDateFields ? raw : { year: "numeric", month: "short", day: "numeric", ...raw };
+  }
+  if (kind === "time") {
+    return hasTimeFields ? { ...secondsForFraction, ...raw } : { hour: "numeric", minute: "2-digit", ...secondsForFraction, ...raw };
+  }
+  return {
+    ...hasDateFields ? {} : { year: "numeric", month: "short", day: "numeric" },
+    ...hasTimeFields ? {} : { hour: "numeric", minute: "2-digit" },
+    ...secondsForFraction,
+    ...raw
+  };
+}
+
+// src/captures.ts
+var BUILT_IN_CAPTURE_MESSAGES = {
+  "en-US": {
+    "identification.issueDate": "issued {value}",
+    "identification.expiryDate": "expires {value}",
+    "signature.type.signature": "Signature",
+    "signature.type.initials": "Initials",
+    "signature.method.drawn": "drawn",
+    "signature.method.typed": "typed",
+    "signature.method.uploaded": "uploaded",
+    "signature.method.certificate": "certificate",
+    "signature.on": "on"
+  },
+  "en-GB": {
+    "identification.issueDate": "issued {value}",
+    "identification.expiryDate": "expires {value}",
+    "signature.type.signature": "Signature",
+    "signature.type.initials": "Initials",
+    "signature.method.drawn": "drawn",
+    "signature.method.typed": "typed",
+    "signature.method.uploaded": "uploaded",
+    "signature.method.certificate": "certificate",
+    "signature.on": "on"
+  },
+  "de-DE": {
+    "identification.issueDate": "ausgestellt {value}",
+    "identification.expiryDate": "g\xFCltig bis {value}",
+    "signature.type.signature": "Unterschrift",
+    "signature.type.initials": "Initialen",
+    "signature.method.drawn": "gezeichnet",
+    "signature.method.typed": "getippt",
+    "signature.method.uploaded": "hochgeladen",
+    "signature.method.certificate": "Zertifikat",
+    "signature.on": "am"
+  },
+  "fr-FR": {
+    "identification.issueDate": "d\xE9livr\xE9 le {value}",
+    "identification.expiryDate": "expire le {value}",
+    "signature.type.signature": "Signature",
+    "signature.type.initials": "Initiales",
+    "signature.method.drawn": "dessin\xE9e",
+    "signature.method.typed": "saisie",
+    "signature.method.uploaded": "t\xE9l\xE9vers\xE9e",
+    "signature.method.certificate": "certificat",
+    "signature.on": "le"
+  },
+  "ar-SA": {
+    "identification.issueDate": "\u0635\u062F\u0631 \u0641\u064A {value}",
+    "identification.expiryDate": "\u064A\u0646\u062A\u0647\u064A \u0641\u064A {value}",
+    "signature.type.signature": "\u062A\u0648\u0642\u064A\u0639",
+    "signature.type.initials": "\u0627\u0644\u0623\u062D\u0631\u0641 \u0627\u0644\u0623\u0648\u0644\u0649",
+    "signature.method.drawn": "\u0645\u0631\u0633\u0648\u0645",
+    "signature.method.typed": "\u0645\u0643\u062A\u0648\u0628",
+    "signature.method.uploaded": "\u0645\u0631\u0641\u0648\u0639",
+    "signature.method.certificate": "\u0634\u0647\u0627\u062F\u0629",
+    "signature.on": "\u0641\u064A"
+  }
+};
+function stringMember2(kind, object, key, issues, options) {
+  const value = object[key];
+  if (isMissing(value)) {
+    if (options.required) issues.push(issue(kind, "missing_member", `${key} is required.`, key));
+    return void 0;
+  }
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > options.maxLength) {
+    issues.push(issue(kind, "invalid_member", `${key} must be a non-empty string of at most ${options.maxLength} characters.`, key));
+    return void 0;
+  }
+  return value;
+}
+function numberMember(kind, object, key, issues, minimum, maximum) {
+  const value = object[key];
+  if (isMissing(value)) {
+    issues.push(issue(kind, "missing_member", `${key} is required.`, key));
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
+    issues.push(issue(kind, "invalid_member", `${key} must be a finite number between ${minimum} and ${maximum}.`, key));
+    return void 0;
+  }
+  return value;
+}
+function validateCoordinate(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("coordinate", "missing_value", "Coordinate value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("coordinate", "invalid_object", "Coordinate value must be an object.")] };
+  }
+  const issues = [];
+  const lat = numberMember("coordinate", value, "lat", issues, -90, 90);
+  const lon = numberMember("coordinate", value, "lon", issues, -180, 180);
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return { ok: true, value: { lat, lon } };
+}
+function prefixIssues(prefix, issues, kind) {
+  return issues.map((item) => ({
+    ...item,
+    kind,
+    path: item.path === void 0 ? prefix : `${prefix}.${item.path}`
+  }));
+}
+function validateBbox(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("bbox", "missing_value", "Bbox value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("bbox", "invalid_object", "Bbox value must be an object.")] };
+  }
+  const issues = [];
+  let southWest;
+  let northEast;
+  if (isMissing(value.southWest)) {
+    issues.push(issue("bbox", "missing_member", "southWest is required.", "southWest"));
+  } else {
+    const validation = validateCoordinate(value.southWest);
+    if (validation.ok) southWest = validation.value;
+    else issues.push(...prefixIssues("southWest", validation.issues, "bbox"));
+  }
+  if (isMissing(value.northEast)) {
+    issues.push(issue("bbox", "missing_member", "northEast is required.", "northEast"));
+  } else {
+    const validation = validateCoordinate(value.northEast);
+    if (validation.ok) northEast = validation.value;
+    else issues.push(...prefixIssues("northEast", validation.issues, "bbox"));
+  }
+  if (southWest !== void 0 && northEast !== void 0) {
+    if (southWest.lat >= northEast.lat) {
+      issues.push(issue("bbox", "invalid_bounds", "southWest latitude must be less than northEast latitude.", "southWest.lat"));
+    }
+    if (southWest.lon >= northEast.lon) {
+      issues.push(issue("bbox", "invalid_bounds", "southWest longitude must be less than northEast longitude.", "southWest.lon"));
+    }
+  }
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return { ok: true, value: { southWest, northEast } };
+}
+var DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+var SIGNATURE_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?Z$/;
+function validateIdentificationDate(value, key, issues) {
+  if (isMissing(value)) return void 0;
+  if (typeof value !== "string" || !DATE_ONLY_PATTERN.test(value) || !validateDate(value).ok) {
+    issues.push(issue("identification", "invalid_member", `${key} must be a valid ISO calendar date.`, key));
+    return void 0;
+  }
+  return value;
+}
+function validateIdentification(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("identification", "missing_value", "Identification value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("identification", "invalid_object", "Identification value must be an object.")] };
+  }
+  const issues = [];
+  const type = stringMember2("identification", value, "type", issues, { required: true, maxLength: 50 });
+  const number = stringMember2("identification", value, "number", issues, { required: true, maxLength: 100 });
+  const issuer = stringMember2("identification", value, "issuer", issues, { maxLength: 100 });
+  const issueDate = validateIdentificationDate(value.issueDate, "issueDate", issues);
+  const expiryDate = validateIdentificationDate(value.expiryDate, "expiryDate", issues);
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return {
+    ok: true,
+    value: {
+      type,
+      number,
+      ...issuer === void 0 ? {} : { issuer },
+      ...issueDate === void 0 ? {} : { issueDate },
+      ...expiryDate === void 0 ? {} : { expiryDate }
+    }
+  };
+}
+function validateAttachment(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("attachment", "missing_value", "Attachment value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("attachment", "invalid_object", "Attachment value must be an object.")] };
+  }
+  const issues = [];
+  const name = stringMember2("attachment", value, "name", issues, { required: true, maxLength: 255 });
+  const mimeType = stringMember2("attachment", value, "mimeType", issues, { required: true, maxLength: 100 });
+  const checksum = value.checksum;
+  if (!isMissing(checksum) && (typeof checksum !== "string" || !/^sha256:[a-f0-9]{64}$/.test(checksum))) {
+    issues.push(issue("attachment", "invalid_member", "checksum must be a lowercase SHA-256 digest.", "checksum"));
+  }
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return {
+    ok: true,
+    value: {
+      name,
+      mimeType,
+      ...checksum === void 0 ? {} : { checksum }
+    }
+  };
+}
+var SIGNATURE_METHODS = ["drawn", "typed", "uploaded", "certificate"];
+var SIGNATURE_TYPES = ["signature", "initials"];
+function validateSignature(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("signature", "missing_value", "Signature value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("signature", "invalid_object", "Signature value must be an object.")] };
+  }
+  const issues = [];
+  const timestampValue = value.timestamp;
+  let timestamp;
+  if (isMissing(timestampValue)) {
+    issues.push(issue("signature", "missing_member", "timestamp is required.", "timestamp"));
+  } else if (typeof timestampValue !== "string" || timestampValue.length === 0 || !SIGNATURE_TIMESTAMP_PATTERN.test(timestampValue)) {
+    issues.push(issue("signature", "invalid_member", "timestamp must be a UTC ISO datetime string using a T separator and Z offset.", "timestamp"));
+  } else {
+    const temporal = validateDatetime(timestampValue);
+    if (!temporal.ok) {
+      for (const item of temporal.issues) {
+        issues.push({
+          ...item,
+          kind: "signature",
+          path: `timestamp${item.path === void 0 ? "" : `.${item.path}`}`
+        });
+      }
+    } else {
+      timestamp = timestampValue;
+    }
+  }
+  const methodValue = value.method;
+  let method;
+  if (isMissing(methodValue)) {
+    issues.push(issue("signature", "missing_member", "method is required.", "method"));
+  } else if (typeof methodValue !== "string" || !SIGNATURE_METHODS.includes(methodValue)) {
+    issues.push(issue("signature", "invalid_member", "method must be drawn, typed, uploaded, or certificate.", "method"));
+  } else {
+    method = methodValue;
+  }
+  const typeValue = value.type;
+  let type = "signature";
+  if (!isMissing(typeValue)) {
+    if (typeof typeValue !== "string" || !SIGNATURE_TYPES.includes(typeValue)) {
+      issues.push(issue("signature", "invalid_member", "type must be signature or initials.", "type"));
+    } else {
+      type = typeValue;
+    }
+  }
+  const image = value.image;
+  if (!isMissing(image) && (typeof image !== "string" || image.length === 0)) {
+    issues.push(issue("signature", "invalid_member", "image must be a non-empty string.", "image"));
+  }
+  const metadata = value.metadata;
+  if (!isMissing(metadata) && !isRecord(metadata)) {
+    issues.push(issue("signature", "invalid_member", "metadata must be an object.", "metadata"));
+  }
+  if (issues.length > 0) return { ok: false, status: statusForIssues(issues), issues };
+  return {
+    ok: true,
+    value: {
+      timestamp,
+      method,
+      type,
+      ...image === void 0 ? {} : { image },
+      ...metadata === void 0 ? {} : { metadata }
+    }
+  };
+}
+function interpolate(message, value) {
+  return message.includes("{value}") ? message.replaceAll("{value}", value) : `${message} ${value}`;
+}
+function formatCoordinateValue(value, options, context) {
+  const numberOptions = { maximumFractionDigits: 9, ...options };
+  return `${context.formatNumber(value.lat, numberOptions)}; ${context.formatNumber(value.lon, numberOptions)}`;
+}
+function formatBboxValue(value, options, context) {
+  return [
+    context.formatCoordinate(value.southWest, options),
+    context.formatCoordinate(value.northEast, options)
+  ].join(" | ");
+}
+function formatIdentificationValue(value, options, context) {
+  const details = [];
+  if (value.issuer !== void 0) details.push(value.issuer);
+  if (value.issueDate !== void 0) {
+    const date = context.formatDate(value.issueDate, options);
+    details.push(interpolate(resolveMessage(context, "identification.issueDate"), date));
+  }
+  if (value.expiryDate !== void 0) {
+    const date = context.formatDate(value.expiryDate, options);
+    details.push(interpolate(resolveMessage(context, "identification.expiryDate"), date));
+  }
+  return `${value.type}: ${value.number}${details.length === 0 ? "" : ` (${details.join(", ")})`}`;
+}
+function formatAttachmentValue(value) {
+  return `${value.name} (${value.mimeType})`;
+}
+function formatSignatureValue(value, options, context) {
+  const type = resolveMessage(context, `signature.type.${value.type ?? "signature"}`);
+  const method = resolveMessage(context, `signature.method.${value.method}`);
+  const on = resolveMessage(context, "signature.on");
+  const date = context.formatDate(value.timestamp, options);
+  return `${type} (${method}) ${on} ${date}`;
+}
+
+// src/selection.ts
+var MISSING_RATING_SCALE = "missing_scale";
+var UNSUPPORTED_LIST_JOIN = "unsupported_list";
+var SelectionFormatError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "SelectionFormatError";
+  }
+  status;
+  code;
+};
+var BUILT_IN_SELECTION_MESSAGES = {
+  "en-US": { "boolean.true": "Yes", "boolean.false": "No", "rating.scale": "{value} of {max}" },
+  "en-GB": { "boolean.true": "Yes", "boolean.false": "No", "rating.scale": "{value} of {max}" },
+  "de-DE": { "boolean.true": "Ja", "boolean.false": "Nein", "rating.scale": "{value} von {max}" },
+  "fr-FR": { "boolean.true": "Oui", "boolean.false": "Non", "rating.scale": "{value} sur {max}" },
+  "ar-SA": { "boolean.true": "\u0646\u0639\u0645", "boolean.false": "\u0644\u0627", "rating.scale": "{value} \u0645\u0646 {max}" }
+};
+var LIST_TYPES = ["conjunction", "disjunction", "unit"];
+var LIST_STYLES = ["long", "short", "narrow"];
+var UNKNOWN_OPTION_POLICIES = ["error", "value"];
+var RATING_DISPLAYS = ["scale", "value"];
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function validateBoolean(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("boolean", "missing_value", "Boolean value is missing.")] };
+  }
+  if (typeof value !== "boolean") {
+    return { ok: false, status: "invalid", issues: [issue("boolean", "invalid_boolean", "Boolean value must be true or false.")] };
+  }
+  return { ok: true, value };
+}
+function validateEnumValue(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("enum", "missing_value", "Enum value is missing.")] };
+  }
+  if (!isOptionValue(value)) {
+    return { ok: false, status: "invalid", issues: [issue("enum", "invalid_enum", "Enum value must be a string or a finite number.")] };
+  }
+  return { ok: true, value };
+}
+function validateMultiselectValue(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("multiselect", "missing_value", "Multiselect value is missing.")] };
+  }
+  if (!Array.isArray(value)) {
+    return { ok: false, status: "invalid", issues: [issue("multiselect", "invalid_multiselect", "Multiselect value must be an array of selected option values.")] };
+  }
+  const issues = [];
+  value.forEach((entry, index) => {
+    if (!isOptionValue(entry)) {
+      issues.push(issue("multiselect", "invalid_member", "Every selected value must be a string or a finite number.", `[${index}]`));
+    }
+  });
+  if (issues.length > 0) return { ok: false, status: "invalid", issues };
+  return { ok: true, value };
+}
+function validateRating(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("rating", "missing_value", "Rating value is missing.")] };
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return { ok: false, status: "invalid", issues: [issue("rating", "invalid_rating", "Rating value must be a finite number.")] };
+  }
+  return { ok: true, value };
+}
+function validateBooleanOptions(options) {
+  for (const key of ["trueLabel", "falseLabel"]) {
+    const label = options[key];
+    if (label !== void 0 && typeof label !== "string") throw new Error(`The boolean ${key} must be a string.`);
+  }
+}
+function validateOptionList(kind, options) {
+  if (options.options !== void 0) {
+    if (!Array.isArray(options.options)) throw new Error(`The ${kind} options must be an array of declared options.`);
+    for (const option of options.options) {
+      if (option === null || typeof option !== "object" || !isOptionValue(option.value)) {
+        throw new Error(`Every ${kind} option must declare a string or finite number value.`);
+      }
+    }
+  }
+  if (options.unknownOption !== void 0 && !UNKNOWN_OPTION_POLICIES.includes(options.unknownOption)) {
+    throw new Error(`The ${kind} unknownOption policy must be error or value.`);
+  }
+}
+function validateMultiselectOptions(options) {
+  validateOptionList("multiselect", options);
+  if (options.listType !== void 0 && !LIST_TYPES.includes(options.listType)) {
+    throw new Error("The multiselect listType must be conjunction, disjunction, or unit.");
+  }
+  if (options.listStyle !== void 0 && !LIST_STYLES.includes(options.listStyle)) {
+    throw new Error("The multiselect listStyle must be long, short, or narrow.");
+  }
+}
+function validateRatingOptions(options) {
+  if (options.max !== void 0 && (typeof options.max !== "number" || !Number.isFinite(options.max))) {
+    throw new Error("The rating max must be a finite number.");
+  }
+  if (options.display !== void 0 && !RATING_DISPLAYS.includes(options.display)) {
+    throw new Error("The rating display must be scale or value.");
+  }
+}
+function validateSelectionOptions(kind, options) {
+  if (kind === "boolean") return validateBooleanOptions(options);
+  if (kind === "enum") return validateOptionList("enum", options);
+  if (kind === "multiselect") return validateMultiselectOptions(options);
+  return validateRatingOptions(options);
+}
+function formatBooleanValue(value, options, context) {
+  const supplied = value ? options.trueLabel : options.falseLabel;
+  if (supplied !== void 0) return supplied;
+  return resolveMessage(context, value ? "boolean.true" : "boolean.false");
+}
+function formatEnumValue(value, options, kind = "enum") {
+  const option = (options.options ?? []).find((candidate) => candidate.value === value);
+  if (option !== void 0) return option.label ?? String(value);
+  if ((options.unknownOption ?? "error") === "value") return String(value);
+  throw new SelectionFormatError(
+    "invalid",
+    "unknown_option",
+    `No declared ${kind} option carries the value ${JSON.stringify(value)}.`
+  );
+}
+function formatMultiselectValue(value, options, context) {
+  const labels = value.map((entry) => context.formatEnum(entry, options));
+  const listFormat = context.listFormat(options.listType ?? "conjunction", options.listStyle ?? "long");
+  if (listFormat === void 0) {
+    throw new SelectionFormatError(
+      "unsupported",
+      UNSUPPORTED_LIST_JOIN,
+      `Locale ${JSON.stringify(context.locale)} has no list conjunction in this runtime.`
+    );
+  }
+  return listFormat.format(labels);
+}
+function formatRatingValue(value, options, context) {
+  const number = context.formatNumber(value, {});
+  if ((options.display ?? "scale") === "value") return number;
+  if (options.max === void 0) {
+    throw new SelectionFormatError("unsupported", MISSING_RATING_SCALE, "The rating declares no maximum, so it has no scale to print.");
+  }
+  const template = resolveMessage(context, "rating.scale");
+  return template.replaceAll("{value}", number).replaceAll("{max}", context.formatNumber(options.max, {}));
+}
+
+// src/errors.ts
+var FormatError = class extends Error {
+  status;
+  kind;
+  issues;
+  constructor(status, kind, issues) {
+    super(issues[0]?.message ?? `Unable to format ${kind}`);
+    this.name = "FormatError";
+    this.status = status;
+    this.kind = kind;
+    this.issues = issues;
+  }
+};
+var FormatConfigurationError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "FormatConfigurationError";
+  }
+};
+var UnsupportedLocaleError = class extends FormatConfigurationError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UnsupportedLocaleError";
+  }
+};
+function isFormatError(value) {
+  return value instanceof FormatError;
+}
+
+// src/types.ts
+var FORMAT_KIND_FAMILIES = {
+  money: "numeric",
+  address: "contact",
+  phone: "contact",
+  person: "contact",
+  organization: "contact",
+  party: "contact",
+  coordinate: "capture",
+  bbox: "capture",
+  duration: "temporal",
+  identification: "capture",
+  attachment: "capture",
+  signature: "capture",
+  date: "temporal",
+  datetime: "temporal",
+  time: "temporal",
+  number: "numeric",
+  percentage: "numeric",
+  boolean: "selection",
+  enum: "selection",
+  multiselect: "selection",
+  rating: "selection"
+};
+var FORMAT_KINDS = Object.freeze(Object.keys(FORMAT_KIND_FAMILIES));
+function isFormatKind(kind) {
+  return typeof kind === "string" && Object.hasOwn(FORMAT_KIND_FAMILIES, kind);
+}
+
+// src/formatter.ts
+var DEFAULT_LOCALE = "en-US";
+var DEFAULT_TIME_ZONE = "UTC";
+var DEFAULT_CALENDAR = "gregory";
+var CACHE_BUCKETS = [
+  "number",
+  "money",
+  "percentage",
+  "date",
+  "datetime",
+  "time",
+  "timeZone",
+  "duration",
+  "durationPlural",
+  "durationList",
+  "selectionList"
+];
+function formatted(value) {
+  return { success: true, status: "formatted", value };
+}
+function failed(status, issues) {
+  return { success: false, status, issues };
+}
+function cloneAndFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((item) => cloneAndFreeze(item)));
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = cloneAndFreeze(item);
+  }
+  return Object.freeze(result);
+}
+function mergeMessages(base, addition) {
+  const result = {};
+  for (const [locale, messages] of Object.entries(base ?? {})) {
+    result[locale] = { ...messages };
+  }
+  for (const [locale, messages] of Object.entries(addition ?? {})) {
+    result[locale] = { ...result[locale] ?? {}, ...messages };
+  }
+  return cloneAndFreeze(result);
+}
+function canonicalLocale(locale) {
+  if (typeof locale !== "string" || locale.trim().length === 0) {
+    throw new FormatConfigurationError("Locale must be a non-empty BCP 47 language tag.");
+  }
+  try {
+    return Intl.getCanonicalLocales(locale)[0] ?? locale;
+  } catch (error) {
+    throw new FormatConfigurationError(`Invalid locale ${JSON.stringify(locale)}.`, { cause: error });
+  }
+}
+function supportedLocale(locale) {
+  try {
+    return Intl.NumberFormat.supportedLocalesOf([locale]).length > 0;
+  } catch {
+    return false;
+  }
+}
+function supportedValue(kind, value) {
+  const supportedValuesOf = Intl.supportedValuesOf;
+  if (typeof supportedValuesOf === "function") {
+    return supportedValuesOf(kind).includes(value);
+  }
+  return true;
+}
+function validateNumberingSystem(numberingSystem) {
+  if (numberingSystem === void 0) return;
+  if (!/^[a-z0-9]{3,8}$/i.test(numberingSystem) || !supportedValue("numberingSystem", numberingSystem)) {
+    throw new FormatConfigurationError(`Unsupported numbering system ${JSON.stringify(numberingSystem)}.`);
+  }
+}
+function validateCalendar(calendar) {
+  if (!/^[a-z0-9-]+$/i.test(calendar) || !supportedValue("calendar", calendar)) {
+    throw new FormatConfigurationError(`Unsupported calendar ${JSON.stringify(calendar)}.`);
+  }
+}
+function timeZoneFormat(timeZone, locale) {
+  try {
+    return new Intl.DateTimeFormat(locale, { timeZone });
+  } catch (error) {
+    throw new FormatConfigurationError(`Unsupported timezone ${JSON.stringify(timeZone)}.`, { cause: error });
+  }
+}
+function resolveConfiguredLocale(requested, policy, fallbackLocale) {
+  const locale = canonicalLocale(requested);
+  if (supportedLocale(locale)) return locale;
+  if (policy !== "fallback") {
+    throw new UnsupportedLocaleError(`Locale ${JSON.stringify(requested)} is not supported by this runtime.`);
+  }
+  if (fallbackLocale === void 0) {
+    throw new UnsupportedLocaleError(
+      `Locale ${JSON.stringify(requested)} is unsupported and no fallbackLocale was supplied.`
+    );
+  }
+  return fallbackLocale;
+}
+function resolveCacheSize(value) {
+  const cacheSize = value ?? DEFAULT_CACHE_SIZE;
+  if (!Number.isInteger(cacheSize) || cacheSize < 1 || cacheSize > MAX_CACHE_SIZE) {
+    throw new FormatConfigurationError(`cacheSize must be an integer between 1 and ${MAX_CACHE_SIZE}.`);
+  }
+  return cacheSize;
+}
+function intlOptions(options) {
+  const { locale: _locale, numberingSystem: _numberingSystem, timeZone: _timeZone, calendar: _calendar, ...intl } = options;
+  return intl;
+}
+function mergeKindOptions(kind, base, addition) {
+  const merged = { ...base, ...addition ?? {} };
+  if (kind === "address" && addition?.countryLayouts !== void 0) {
+    merged.countryLayouts = { ...base.countryLayouts ?? {}, ...addition.countryLayouts };
+  }
+  return Object.freeze(merged);
+}
+function mergeConfig(base, addition) {
+  const kinds = {};
+  for (const kind of FORMAT_KINDS) {
+    kinds[kind] = mergeKindOptions(kind, base[kind], addition[kind]);
+  }
+  return {
+    locale: addition.locale ?? base.locale,
+    fallbackLocale: addition.fallbackLocale ?? base.fallbackLocale,
+    unsupportedLocale: addition.unsupportedLocale ?? base.unsupportedLocale,
+    timeZone: addition.timeZone ?? base.timeZone,
+    calendar: addition.calendar ?? base.calendar,
+    numberingSystem: addition.numberingSystem ?? base.numberingSystem,
+    cacheSize: addition.cacheSize ?? base.cacheSize,
+    ...kinds,
+    messages: mergeMessages(base.messages, addition.messages)
+  };
+}
+function validateNumber(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("number", "missing_value", "Number value is missing.")] };
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return { ok: false, status: "invalid", issues: [issue("number", "invalid_number", "Number value must be a finite number.")] };
+  }
+  return { ok: true, value };
+}
+function validatePercentage(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("percentage", "missing_value", "Percentage value is missing.")] };
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      ok: false,
+      status: "invalid",
+      issues: [issue("percentage", "invalid_percentage", "Percentage value must be a finite number of percentage points.")]
+    };
+  }
+  return { ok: true, value };
+}
+function validateMoney(value) {
+  if (isMissing(value)) {
+    return { ok: false, status: "missing", issues: [issue("money", "missing_value", "Money value is missing.")] };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, status: "invalid", issues: [issue("money", "invalid_object", "Money value must be an object with amount and currency.")] };
+  }
+  const amount = value.amount;
+  const currency = value.currency;
+  const issues = [];
+  if (isMissing(amount)) {
+    issues.push(issue("money", "missing_member", "Money amount is required.", "amount"));
+  } else if (typeof amount !== "number" || !Number.isFinite(amount)) {
+    issues.push(issue("money", "invalid_member", "Money amount must be a finite number.", "amount"));
+  }
+  if (isMissing(currency)) {
+    issues.push(issue("money", "missing_member", "Money currency is required; no default currency is applied.", "currency"));
+  } else if (typeof currency !== "string" || !/^[A-Z]{3}$/.test(currency)) {
+    issues.push(issue("money", "invalid_member", "Money currency must be an uppercase ISO 4217 alpha-3 code.", "currency"));
+  }
+  if (issues.length > 0) {
+    const status = issues.some((item) => item.code === "invalid_member") ? "invalid" : "incomplete";
+    return { ok: false, status, issues };
+  }
+  return { ok: true, value: { amount, currency } };
+}
+function checked(validation) {
+  return validation.ok ? { ok: true, value: { value: validation.value, parsed: validation.value } } : validation;
+}
+function checkedInput(input, validation) {
+  return validation.ok ? { ok: true, value: { value: input, parsed: validation.value } } : validation;
+}
+var VALUE_CHECKS = {
+  number: (value) => checked(validateNumber(value)),
+  money: (value) => checked(validateMoney(value)),
+  percentage: (value) => checked(validatePercentage(value)),
+  address: (value) => checked(validateAddress(value)),
+  phone: (value) => checked(validatePhone(value)),
+  person: (value) => checked(validatePerson(value)),
+  organization: (value) => checked(validateOrganization(value)),
+  party: (value, options) => {
+    const validation = validateParty(value, options);
+    return validation.ok ? { ok: true, value: { value: validation.value.value, parsed: validation.value } } : validation;
+  },
+  date: (value) => checkedInput(value, validateDate(value)),
+  datetime: (value) => checkedInput(value, validateDatetime(value)),
+  time: (value) => checkedInput(value, validateTime(value)),
+  duration: (value) => checkedInput(value, validateDuration(value)),
+  coordinate: (value) => checked(validateCoordinate(value)),
+  bbox: (value) => checked(validateBbox(value)),
+  identification: (value) => checked(validateIdentification(value)),
+  attachment: (value) => checked(validateAttachment(value)),
+  signature: (value) => checked(validateSignature(value)),
+  boolean: (value) => checked(validateBoolean(value)),
+  enum: (value) => checked(validateEnumValue(value)),
+  multiselect: (value) => checked(validateMultiselectValue(value)),
+  rating: (value) => checked(validateRating(value))
+};
+function buildPercentageIntlOptions(options) {
+  const percentageOptions = {
+    ...options,
+    style: "percent"
+  };
+  if (percentageOptions.minimumFractionDigits === void 0 && percentageOptions.maximumFractionDigits === void 0 && percentageOptions.maximumSignificantDigits === void 0 && percentageOptions.minimumSignificantDigits === void 0) {
+    percentageOptions.maximumFractionDigits = 2;
+  }
+  return percentageOptions;
+}
+var DIGIT_OPTIONS = [
+  "minimumFractionDigits",
+  "maximumFractionDigits",
+  "minimumSignificantDigits",
+  "maximumSignificantDigits"
+];
+var currencyDigitCache = /* @__PURE__ */ new Map();
+function currencyFractionDigits(currency) {
+  const cached = currencyDigitCache.get(currency);
+  if (cached) return cached;
+  const { minimumFractionDigits = 2, maximumFractionDigits = 2 } = new Intl.NumberFormat("en", {
+    style: "currency",
+    currency
+  }).resolvedOptions();
+  const digits = { minimumFractionDigits, maximumFractionDigits };
+  currencyDigitCache.set(currency, digits);
+  return digits;
+}
+function buildMoneyIntlOptions(options, currency) {
+  const currencyDisplay = options.currencyDisplay ?? "symbol";
+  const { currencyDisplay: _currencyDisplay, currencySign, ...numberOptions } = options;
+  if (currencyDisplay === "none") {
+    const setsDigits = DIGIT_OPTIONS.some((key) => numberOptions[key] !== void 0);
+    return setsDigits ? { ...numberOptions } : { ...currencyFractionDigits(currency), ...numberOptions };
+  }
+  return {
+    ...numberOptions,
+    style: "currency",
+    currency,
+    currencyDisplay,
+    ...currencySign === void 0 ? {} : { currencySign }
+  };
+}
+function numericIntlOptions(kind, options, currency) {
+  if (kind === "money") return buildMoneyIntlOptions(options, currency);
+  if (kind === "percentage") return buildPercentageIntlOptions(options);
+  return options;
+}
+function intlFor(kind, locale, create) {
+  try {
+    return create();
+  } catch (error) {
+    throw new FormatConfigurationError(
+      `Invalid ${kind} formatting options for locale ${JSON.stringify(locale)}: ${error instanceof Error ? error.message : "unknown option error"}.`,
+      { cause: error }
+    );
+  }
+}
+function createNumberFormat(kind, policy, options) {
+  return intlFor(kind, policy.locale, () => new Intl.NumberFormat(policy.locale, {
+    ...options,
+    ...policy.numberingSystem === void 0 ? {} : { numberingSystem: policy.numberingSystem }
+  }));
+}
+function createDateTimeFormat(kind, policy, timeZone, options) {
+  return intlFor(kind, policy.locale, () => new Intl.DateTimeFormat(policy.locale, {
+    ...options,
+    calendar: policy.calendar,
+    timeZone,
+    ...policy.numberingSystem === void 0 ? {} : { numberingSystem: policy.numberingSystem }
+  }));
+}
+function guardOptions(kind, check) {
+  try {
+    check();
+  } catch (error) {
+    throw new FormatConfigurationError(error instanceof Error ? error.message : `Invalid ${kind} formatting options.`, { cause: error });
+  }
+}
+function createConfig(options) {
+  const policy = options.unsupportedLocale ?? "error";
+  const fallbackLocale = options.fallbackLocale === void 0 ? void 0 : canonicalLocale(options.fallbackLocale);
+  if (fallbackLocale !== void 0 && !supportedLocale(fallbackLocale)) {
+    throw new UnsupportedLocaleError(`Fallback locale ${JSON.stringify(options.fallbackLocale)} is not supported by this runtime.`);
+  }
+  const locale = resolveConfiguredLocale(options.locale ?? DEFAULT_LOCALE, policy, fallbackLocale);
+  const timeZone = options.timeZone ?? DEFAULT_TIME_ZONE;
+  const calendar = options.calendar ?? DEFAULT_CALENDAR;
+  validateNumberingSystem(options.numberingSystem);
+  validateCalendar(calendar);
+  timeZoneFormat(timeZone, locale);
+  const kinds = {};
+  for (const kind of FORMAT_KINDS) kinds[kind] = cloneAndFreeze(options[kind] ?? {});
+  return {
+    locale,
+    fallbackLocale,
+    unsupportedLocale: policy,
+    timeZone,
+    calendar,
+    numberingSystem: options.numberingSystem,
+    cacheSize: resolveCacheSize(options.cacheSize),
+    ...kinds,
+    messages: mergeMessages(
+      mergeMessages(
+        mergeMessages(mergeMessages(BUILT_IN_CONTACT_MESSAGES, BUILT_IN_TEMPORAL_MESSAGES), BUILT_IN_CAPTURE_MESSAGES),
+        BUILT_IN_SELECTION_MESSAGES
+      ),
+      options.messages
+    )
+  };
+}
+function overrideLayers(overrides) {
+  if (overrides === void 0) return [];
+  const layers = [];
+  for (const kind of FORMAT_KINDS) {
+    const implementation = overrides[kind];
+    if (implementation === void 0) continue;
+    if (typeof implementation !== "function") {
+      throw new FormatConfigurationError(`Override for ${kind} must be a function.`);
+    }
+    layers.push({ kind, implementation });
+  }
+  return layers;
+}
+var FormatterImpl = class _FormatterImpl {
+  locale;
+  fallbackLocale;
+  timeZone;
+  calendar;
+  numberingSystem;
+  messages;
+  config;
+  caches;
+  layers;
+  chains;
+  constructor(options = {}, layers = []) {
+    this.config = createConfig(options);
+    this.locale = this.config.locale;
+    this.fallbackLocale = this.config.fallbackLocale;
+    this.timeZone = this.config.timeZone;
+    this.calendar = this.config.calendar;
+    this.numberingSystem = this.config.numberingSystem;
+    this.messages = this.config.messages;
+    const caches = {};
+    for (const bucket of CACHE_BUCKETS) caches[bucket] = new BoundedCache(this.config.cacheSize);
+    this.caches = caches;
+    for (const kind of FORMAT_KINDS) this.checkConfiguredOptions(kind);
+    this.layers = [...layers, ...overrideLayers(options.overrides)];
+    const chains = {};
+    for (const layer of this.layers) {
+      chains[layer.kind] = { implementation: layer.implementation, previous: chains[layer.kind] };
+    }
+    this.chains = chains;
+  }
+  checkConfiguredOptions(kind) {
+    const { options, policy } = this.resolve(kind, this.config[kind], false);
+    const intl = intlOptions(options);
+    if (kind === "number" || kind === "money" || kind === "percentage") {
+      createNumberFormat(kind, policy, numericIntlOptions(kind, intl, "USD"));
+    } else if (kind === "date" || kind === "datetime" || kind === "time") {
+      createDateTimeFormat(kind, policy, policy.timeZone, dateTimeDefaults(kind, intl));
+    } else if (kind === "duration") {
+      createNumberFormat(kind, policy, intl);
+    }
+  }
+  /**
+   * Resolves the options and policy of one call. A top-level call inherits the
+   * kind's formatter-level options. A nested call and a delegation do not: they
+   * carry options that were already resolved, so they never pick up a sibling
+   * kind's formatter-level options.
+   */
+  resolve(kind, options, inherit) {
+    const merged = inherit ? mergeKindOptions(kind, this.config[kind], options) : Object.freeze({ ...options ?? {} });
+    const locale = resolveConfiguredLocale(
+      merged.locale ?? this.locale,
+      this.config.unsupportedLocale,
+      this.config.fallbackLocale
+    );
+    const policy = {
+      locale,
+      numberingSystem: merged.numberingSystem ?? this.numberingSystem,
+      calendar: merged.calendar ?? this.calendar,
+      timeZone: merged.timeZone ?? this.timeZone
+    };
+    this.checkOptions(kind, merged, policy);
+    return { options: merged, policy };
+  }
+  /** Rejects call options a kind cannot act on, before any value reaches it. */
+  checkOptions(kind, options, policy) {
+    validateNumberingSystem(policy.numberingSystem);
+    const family = FORMAT_KIND_FAMILIES[kind];
+    if (family === "temporal") {
+      this.checkCalendarAndTimeZone(policy);
+    } else if (kind === "coordinate" || kind === "bbox") {
+      createNumberFormat(kind, policy, intlOptions(options));
+    } else if (kind === "identification" || kind === "signature") {
+      this.checkCalendarAndTimeZone(policy);
+      createDateTimeFormat(kind, policy, policy.timeZone, dateTimeDefaults("date", intlOptions(options)));
+    } else if (family === "contact") {
+      guardOptions(kind, () => validateContactOptions(kind, options));
+    } else if (family === "selection") {
+      guardOptions(kind, () => validateSelectionOptions(kind, options));
+    }
+  }
+  checkCalendarAndTimeZone(policy) {
+    validateCalendar(policy.calendar);
+    this.cached("timeZone", { locale: policy.locale, timeZone: policy.timeZone }, () => timeZoneFormat(policy.timeZone, policy.locale));
+  }
+  cached(bucket, key, create) {
+    const cache = this.caches[bucket];
+    const serialized = stableSerialize(key);
+    const existing = cache.get(serialized);
+    if (existing !== void 0) return existing;
+    const created = create();
+    cache.set(serialized, created);
+    return created;
+  }
+  numberFormat(bucket, kind, policy, options) {
+    return this.cached(
+      bucket,
+      { locale: policy.locale, numberingSystem: policy.numberingSystem, options },
+      () => createNumberFormat(kind, policy, options)
+    );
+  }
+  dateTimeFormat(bucket, kind, policy, timeZone, options) {
+    return this.cached(
+      bucket,
+      { locale: policy.locale, numberingSystem: policy.numberingSystem, options: { calendar: policy.calendar, timeZone, ...options } },
+      () => createDateTimeFormat(kind, policy, timeZone, options)
+    );
+  }
+  messageContext(locale) {
+    return { locale, messages: this.messages, fallbackLocale: this.fallbackLocale };
+  }
+  /**
+   * Runs one step of a kind's chain. The value is checked once per step, so a
+   * delegation that passes a new value is checked too.
+   */
+  invoke(kind, entry, value, call) {
+    const validation = VALUE_CHECKS[kind](value, call.options);
+    if (!validation.ok) throw new FormatError(validation.status, kind, validation.issues);
+    if (entry === void 0) return this.base(kind, validation.value.parsed, call);
+    const current = validation.value.value;
+    const delegate = (nextValue = current, nextOptions) => this.invoke(kind, entry.previous, nextValue, this.resolve(kind, mergeKindOptions(kind, call.options, nextOptions), false));
+    const output = entry.implementation(current, call.options, {
+      kind,
+      locale: call.policy.locale,
+      options: call.options,
+      delegate
+    });
+    if (typeof output !== "string") {
+      throw new FormatError("error", kind, [issue(kind, "implementation_output", "A formatter implementation must return a string.")]);
+    }
+    return output;
+  }
+  /** Formats a value one family formats through another kind, such as a signature's date. */
+  nested(kind, value, options) {
+    return this.invoke(kind, this.chains[kind], value, this.resolve(kind, options, false));
+  }
+  base(kind, parsed, call) {
+    const { options, policy } = call;
+    switch (kind) {
+      case "number":
+      case "money":
+      case "percentage":
+        return this.formatNumeric(kind, parsed, call);
+      case "date":
+      case "datetime": {
+        const value = parsed;
+        const timeZone = value.mode === "instant" ? policy.timeZone : "UTC";
+        return this.dateTimeFormat(kind, kind, policy, timeZone, dateTimeDefaults(kind, intlOptions(options))).format(value.date);
+      }
+      case "time":
+        return this.dateTimeFormat("time", kind, policy, "UTC", dateTimeDefaults("time", intlOptions(options))).format(parsed.date);
+      case "duration":
+        return formatDurationValue(parsed, intlOptions(options), {
+          ...this.messageContext(policy.locale),
+          numberFormat: (durationOptions) => this.numberFormat("duration", kind, policy, durationOptions),
+          pluralRules: (pluralOptions) => this.cached("durationPlural", { locale: policy.locale, options: pluralOptions }, () => new Intl.PluralRules(policy.locale, pluralOptions)),
+          listFormat: () => this.cached("durationList", { locale: policy.locale }, () => new Intl.ListFormat(policy.locale, { style: "long", type: "unit" }))
+        });
+      case "address":
+        return formatAddress(parsed, options, {
+          locale: policy.locale,
+          options
+        });
+      case "phone":
+        return formatPhone(parsed, options, this.messageContext(policy.locale));
+      case "person":
+        return formatPerson(parsed);
+      case "organization":
+        return formatOrganization(parsed, this.messageContext(policy.locale));
+      case "party": {
+        const party = parsed;
+        return this.nested(party.identity, party.value, { locale: policy.locale });
+      }
+      case "coordinate":
+        return formatCoordinateValue(parsed, options, this.captureContext(policy));
+      case "bbox":
+        return formatBboxValue(parsed, options, this.captureContext(policy));
+      case "identification":
+        return formatIdentificationValue(parsed, options, this.captureContext(policy));
+      case "attachment":
+        return formatAttachmentValue(parsed);
+      case "signature":
+        return formatSignatureValue(parsed, options, this.captureContext(policy));
+      case "boolean":
+        return formatBooleanValue(parsed, options, this.selectionContext(policy));
+      case "enum":
+        return formatEnumValue(parsed, options);
+      case "multiselect":
+        return formatMultiselectValue(parsed, options, this.selectionContext(policy));
+      case "rating":
+        return formatRatingValue(parsed, options, this.selectionContext(policy));
+    }
+  }
+  formatNumeric(kind, value, call) {
+    const money = kind === "money" ? value : void 0;
+    const options = numericIntlOptions(kind, intlOptions(call.options), money?.currency ?? "USD");
+    const amount = money === void 0 ? value : money.amount;
+    return this.numberFormat(kind, kind, call.policy, options).format(kind === "percentage" ? amount / 100 : amount);
+  }
+  captureContext(policy) {
+    const { locale } = policy;
+    return {
+      ...this.messageContext(locale),
+      formatNumber: (value, options) => this.nested("number", value, { ...options, locale }),
+      formatCoordinate: (value, options) => this.nested("coordinate", value, { ...options, locale }),
+      formatDate: (value, options) => this.nested("date", value, { ...options, locale })
+    };
+  }
+  selectionContext(policy) {
+    const { locale, numberingSystem } = policy;
+    return {
+      ...this.messageContext(locale),
+      formatNumber: (value, options) => this.nested("number", value, {
+        ...options,
+        locale,
+        ...numberingSystem === void 0 ? {} : { numberingSystem }
+      }),
+      formatEnum: (value, options) => this.nested("enum", value, { ...options, locale }),
+      listFormat: (type, style) => this.selectionListFormat(locale, type, style)
+    };
+  }
+  selectionListFormat(locale, type, style) {
+    if (typeof Intl.ListFormat !== "function" || Intl.ListFormat.supportedLocalesOf([locale]).length === 0) return void 0;
+    return this.cached("selectionList", { locale, type, style }, () => new Intl.ListFormat(locale, { type, style }));
+  }
+  evaluate(kind, value, options) {
+    if (!isFormatKind(kind)) {
+      return failed("unsupported", [issue(kind, "unknown_kind", `Unknown format kind ${JSON.stringify(kind)}.`)]);
+    }
+    try {
+      return formatted(this.invoke(kind, this.chains[kind], value, this.resolve(kind, options, true)));
+    } catch (error) {
+      return failure(kind, error);
+    }
+  }
+  format(kind, value, options) {
+    const result = this.safeFormat(kind, value, options);
+    if (result.success) return result.value;
+    throw new FormatError(result.status, kind, result.issues);
+  }
+  safeFormat(kind, value, options) {
+    return this.evaluate(kind, value, options);
+  }
+  formatNumber(value, options) {
+    return this.format("number", value, options);
+  }
+  formatMoney(value, options) {
+    return this.format("money", value, options);
+  }
+  formatPercentage(value, options) {
+    return this.format("percentage", value, options);
+  }
+  formatAddress(value, options) {
+    return this.format("address", value, options);
+  }
+  formatPhone(value, options) {
+    return this.format("phone", value, options);
+  }
+  formatPerson(value, options) {
+    return this.format("person", value, options);
+  }
+  formatOrganization(value, options) {
+    return this.format("organization", value, options);
+  }
+  formatParty(value, options) {
+    return this.format("party", value, options);
+  }
+  formatDate(value, options) {
+    return this.format("date", value, options);
+  }
+  formatDatetime(value, options) {
+    return this.format("datetime", value, options);
+  }
+  formatTime(value, options) {
+    return this.format("time", value, options);
+  }
+  formatDuration(value, options) {
+    return this.format("duration", value, options);
+  }
+  formatCoordinate(value, options) {
+    return this.format("coordinate", value, options);
+  }
+  formatBbox(value, options) {
+    return this.format("bbox", value, options);
+  }
+  formatIdentification(value, options) {
+    return this.format("identification", value, options);
+  }
+  formatAttachment(value, options) {
+    return this.format("attachment", value, options);
+  }
+  formatSignature(value, options) {
+    return this.format("signature", value, options);
+  }
+  formatBoolean(value, options) {
+    return this.format("boolean", value, options);
+  }
+  formatEnum(value, options) {
+    return this.format("enum", value, options);
+  }
+  formatMultiselect(value, options) {
+    return this.format("multiselect", value, options);
+  }
+  formatRating(value, options) {
+    return this.format("rating", value, options);
+  }
+  safeFormatNumber(value, options) {
+    return this.safeFormat("number", value, options);
+  }
+  safeFormatMoney(value, options) {
+    return this.safeFormat("money", value, options);
+  }
+  safeFormatPercentage(value, options) {
+    return this.safeFormat("percentage", value, options);
+  }
+  safeFormatAddress(value, options) {
+    return this.safeFormat("address", value, options);
+  }
+  safeFormatPhone(value, options) {
+    return this.safeFormat("phone", value, options);
+  }
+  safeFormatPerson(value, options) {
+    return this.safeFormat("person", value, options);
+  }
+  safeFormatOrganization(value, options) {
+    return this.safeFormat("organization", value, options);
+  }
+  safeFormatParty(value, options) {
+    return this.safeFormat("party", value, options);
+  }
+  safeFormatDate(value, options) {
+    return this.safeFormat("date", value, options);
+  }
+  safeFormatDatetime(value, options) {
+    return this.safeFormat("datetime", value, options);
+  }
+  safeFormatTime(value, options) {
+    return this.safeFormat("time", value, options);
+  }
+  safeFormatDuration(value, options) {
+    return this.safeFormat("duration", value, options);
+  }
+  safeFormatCoordinate(value, options) {
+    return this.safeFormat("coordinate", value, options);
+  }
+  safeFormatBbox(value, options) {
+    return this.safeFormat("bbox", value, options);
+  }
+  safeFormatIdentification(value, options) {
+    return this.safeFormat("identification", value, options);
+  }
+  safeFormatAttachment(value, options) {
+    return this.safeFormat("attachment", value, options);
+  }
+  safeFormatSignature(value, options) {
+    return this.safeFormat("signature", value, options);
+  }
+  safeFormatBoolean(value, options) {
+    return this.safeFormat("boolean", value, options);
+  }
+  safeFormatEnum(value, options) {
+    return this.safeFormat("enum", value, options);
+  }
+  safeFormatMultiselect(value, options) {
+    return this.safeFormat("multiselect", value, options);
+  }
+  safeFormatRating(value, options) {
+    return this.safeFormat("rating", value, options);
+  }
+  compose(options = {}) {
+    const { overrides, ...withoutOverrides } = options;
+    return new _FormatterImpl({ ...mergeConfig(this.config, withoutOverrides), overrides }, this.layers);
+  }
+  withOverrides(overrides) {
+    return new _FormatterImpl(this.config, [...this.layers, ...overrideLayers(overrides)]);
+  }
+  cacheStats() {
+    const stats = {};
+    for (const bucket of CACHE_BUCKETS) stats[bucket] = this.caches[bucket].snapshot();
+    return stats;
+  }
+};
+function failure(kind, error) {
+  if (error instanceof FormatError) return failed(error.status, error.issues);
+  if (error instanceof SelectionFormatError) return failed(error.status, [issue(kind, error.code, error.message)]);
+  if (error instanceof MissingMessageError) return failed("unsupported", [issue(kind, "missing_message", error.message, void 0, error)]);
+  if (error instanceof UnsupportedAddressLayoutError) {
+    return failed("unsupported", [issue(kind, "unsupported_country_layout", error.message, "country", error)]);
+  }
+  if (error instanceof UnsupportedLocaleError) return failed("unsupported", [issue(kind, "unsupported_locale", error.message, void 0, error)]);
+  if (error instanceof FormatConfigurationError) return failed("invalid", [issue(kind, "invalid_options", error.message, void 0, error)]);
+  return failed("error", [issue(kind, "implementation_error", error instanceof Error ? error.message : "Unexpected formatter failure.", void 0, error)]);
+}
+function createFormatter(options = {}) {
+  return new FormatterImpl(options);
+}
+var defaultFormatter = createFormatter();
+function formatNumber(value, options) {
+  return defaultFormatter.formatNumber(value, options);
+}
+function formatAddress2(value, options) {
+  return defaultFormatter.formatAddress(value, options);
+}
+function formatMoney(value, options) {
+  return defaultFormatter.formatMoney(value, options);
+}
+function formatPercentage(value, options) {
+  return defaultFormatter.formatPercentage(value, options);
+}
+function formatPhone2(value, options) {
+  return defaultFormatter.formatPhone(value, options);
+}
+function formatPerson2(value, options) {
+  return defaultFormatter.formatPerson(value, options);
+}
+function formatOrganization2(value, options) {
+  return defaultFormatter.formatOrganization(value, options);
+}
+function formatParty(value, options) {
+  return defaultFormatter.formatParty(value, options);
+}
+function formatDate(value, options) {
+  return defaultFormatter.formatDate(value, options);
+}
+function formatDatetime(value, options) {
+  return defaultFormatter.formatDatetime(value, options);
+}
+function formatTime(value, options) {
+  return defaultFormatter.formatTime(value, options);
+}
+function formatDuration(value, options) {
+  return defaultFormatter.formatDuration(value, options);
+}
+function formatCoordinate(value, options) {
+  return defaultFormatter.formatCoordinate(value, options);
+}
+function formatBbox(value, options) {
+  return defaultFormatter.formatBbox(value, options);
+}
+function formatIdentification(value, options) {
+  return defaultFormatter.formatIdentification(value, options);
+}
+function formatAttachment(value, options) {
+  return defaultFormatter.formatAttachment(value, options);
+}
+function formatSignature(value, options) {
+  return defaultFormatter.formatSignature(value, options);
+}
+function formatBoolean(value, options) {
+  return defaultFormatter.formatBoolean(value, options);
+}
+function formatEnum(value, options) {
+  return defaultFormatter.formatEnum(value, options);
+}
+function formatMultiselect(value, options) {
+  return defaultFormatter.formatMultiselect(value, options);
+}
+function formatRating(value, options) {
+  return defaultFormatter.formatRating(value, options);
+}
+function formatValue(kind, value, options) {
+  return defaultFormatter.format(kind, value, options);
+}
+function safeFormatValue(kind, value, options) {
+  return defaultFormatter.safeFormat(kind, value, options);
+}
+function safeFormatNumber(value, options) {
+  return defaultFormatter.safeFormatNumber(value, options);
+}
+function safeFormatAddress(value, options) {
+  return defaultFormatter.safeFormatAddress(value, options);
+}
+function safeFormatMoney(value, options) {
+  return defaultFormatter.safeFormatMoney(value, options);
+}
+function safeFormatPercentage(value, options) {
+  return defaultFormatter.safeFormatPercentage(value, options);
+}
+function safeFormatPhone(value, options) {
+  return defaultFormatter.safeFormatPhone(value, options);
+}
+function safeFormatPerson(value, options) {
+  return defaultFormatter.safeFormatPerson(value, options);
+}
+function safeFormatOrganization(value, options) {
+  return defaultFormatter.safeFormatOrganization(value, options);
+}
+function safeFormatParty(value, options) {
+  return defaultFormatter.safeFormatParty(value, options);
+}
+function safeFormatDate(value, options) {
+  return defaultFormatter.safeFormatDate(value, options);
+}
+function safeFormatDatetime(value, options) {
+  return defaultFormatter.safeFormatDatetime(value, options);
+}
+function safeFormatTime(value, options) {
+  return defaultFormatter.safeFormatTime(value, options);
+}
+function safeFormatDuration(value, options) {
+  return defaultFormatter.safeFormatDuration(value, options);
+}
+function safeFormatCoordinate(value, options) {
+  return defaultFormatter.safeFormatCoordinate(value, options);
+}
+function safeFormatBbox(value, options) {
+  return defaultFormatter.safeFormatBbox(value, options);
+}
+function safeFormatIdentification(value, options) {
+  return defaultFormatter.safeFormatIdentification(value, options);
+}
+function safeFormatAttachment(value, options) {
+  return defaultFormatter.safeFormatAttachment(value, options);
+}
+function safeFormatSignature(value, options) {
+  return defaultFormatter.safeFormatSignature(value, options);
+}
+function safeFormatBoolean(value, options) {
+  return defaultFormatter.safeFormatBoolean(value, options);
+}
+function safeFormatEnum(value, options) {
+  return defaultFormatter.safeFormatEnum(value, options);
+}
+function safeFormatMultiselect(value, options) {
+  return defaultFormatter.safeFormatMultiselect(value, options);
+}
+function safeFormatRating(value, options) {
+  return defaultFormatter.safeFormatRating(value, options);
+}
+export {
+  FORMAT_KINDS,
+  FormatConfigurationError,
+  FormatError,
+  MISSING_RATING_SCALE,
+  UNSUPPORTED_LIST_JOIN,
+  UnsupportedLocaleError,
+  createFormatter,
+  defaultFormatter,
+  formatAddress2 as formatAddress,
+  formatAttachment,
+  formatBbox,
+  formatBoolean,
+  formatCoordinate,
+  formatDate,
+  formatDatetime,
+  formatDuration,
+  formatEnum,
+  formatIdentification,
+  formatMoney,
+  formatMultiselect,
+  formatNumber,
+  formatOrganization2 as formatOrganization,
+  formatParty,
+  formatPercentage,
+  formatPerson2 as formatPerson,
+  formatPhone2 as formatPhone,
+  formatRating,
+  formatSignature,
+  formatTime,
+  formatValue,
+  isFormatError,
+  safeFormatAddress,
+  safeFormatAttachment,
+  safeFormatBbox,
+  safeFormatBoolean,
+  safeFormatCoordinate,
+  safeFormatDate,
+  safeFormatDatetime,
+  safeFormatDuration,
+  safeFormatEnum,
+  safeFormatIdentification,
+  safeFormatMoney,
+  safeFormatMultiselect,
+  safeFormatNumber,
+  safeFormatOrganization,
+  safeFormatParty,
+  safeFormatPercentage,
+  safeFormatPerson,
+  safeFormatPhone,
+  safeFormatRating,
+  safeFormatSignature,
+  safeFormatTime,
+  safeFormatValue
+};