@cliff-format/i18n 0.0.0-stage → 0.2.0

package/dist/lite.cjs

@@ -0,0 +1,1798 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lite.ts
+var lite_exports = {};
+__export(lite_exports, {
+  Catalog: () => Catalog,
+  CliffAmbiguousEntryError: () => CliffAmbiguousEntryError,
+  CliffDuplicateEntryError: () => CliffDuplicateEntryError,
+  CliffI18nError: () => CliffI18nError,
+  CliffIcuError: () => CliffIcuError,
+  CliffMissingEntryError: () => CliffMissingEntryError,
+  CliffMissingMetadataError: () => CliffMissingMetadataError,
+  CliffScopeError: () => CliffScopeError,
+  CliffScopeMismatchError: () => CliffScopeMismatchError,
+  EMOTION: () => EMOTION,
+  MessageBuilderImpl: () => MessageBuilderImpl,
+  STATUS: () => STATUS,
+  STATUS_ORDER: () => STATUS_ORDER,
+  STATUS_TRANSITIONS: () => STATUS_TRANSITIONS,
+  TYPE: () => TYPE,
+  VARIANT: () => VARIANT,
+  analyzePlain: () => analyzePlain,
+  argumentNames: () => argumentNames,
+  assertCatalogParts: () => assertCatalogParts,
+  assertEmotionTag: () => assertEmotionTag,
+  assertScope: () => assertScope,
+  assertStatusTag: () => assertStatusTag,
+  assertTypeTag: () => assertTypeTag,
+  assertVariantTag: () => assertVariantTag,
+  canTransitionStatus: () => canTransitionStatus,
+  createI18n: () => createI18n,
+  createLiteIcu: () => createLiteIcu,
+  createT: () => createT,
+  detectDialect: () => detectDialect,
+  isEmotionTag: () => isEmotionTag,
+  isStatusTag: () => isStatusTag,
+  isTypeTag: () => isTypeTag,
+  isVariantTag: () => isVariantTag,
+  joinCanonical: () => joinCanonical,
+  nextStatuses: () => nextStatuses,
+  reconcileEntryStatus: () => reconcileEntryStatus,
+  resolveEntryId: () => resolveEntryId,
+  statusOf: () => statusOf,
+  statusOrder: () => statusOrder
+});
+module.exports = __toCommonJS(lite_exports);
+
+// src/engine.ts
+var import_core5 = require("@cliff-format/core");
+
+// src/builder.ts
+var import_core2 = require("@cliff-format/core");
+
+// src/errors.ts
+var CliffI18nError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CliffI18nError";
+  }
+};
+var CliffScopeError = class extends CliffI18nError {
+  scope;
+  constructor(message, scope = {}) {
+    super(message);
+    this.name = "CliffScopeError";
+    this.scope = scope;
+  }
+};
+var CliffScopeMismatchError = class extends CliffScopeError {
+  entryId;
+  constructor(entryId, scope, expected) {
+    super(
+      `entry ID "${entryId}" resolves outside the active scope (${scope.namespace}.${scope.clan}); expected ${expected}`,
+      scope
+    );
+    this.name = "CliffScopeMismatchError";
+    this.entryId = entryId;
+  }
+};
+var CliffMissingEntryError = class extends CliffI18nError {
+  entryId;
+  locale;
+  constructor(entryId, locale) {
+    super(`missing CLIFF entry "${entryId}" for locale "${locale}"`);
+    this.name = "CliffMissingEntryError";
+    this.entryId = entryId;
+    this.locale = locale;
+  }
+};
+var CliffAmbiguousEntryError = class extends CliffI18nError {
+  entryId;
+  candidates;
+  constructor(entryId, candidates) {
+    super(`ambiguous CLIFF entry "${entryId}"; candidates: ${candidates.join(", ")}`);
+    this.name = "CliffAmbiguousEntryError";
+    this.entryId = entryId;
+    this.candidates = candidates;
+  }
+};
+var CliffDuplicateEntryError = class extends CliffI18nError {
+  entryId;
+  locale;
+  constructor(entryId, locale) {
+    super(`duplicate canonical CLIFF entry ID "${entryId}" for locale "${locale}"`);
+    this.name = "CliffDuplicateEntryError";
+    this.entryId = entryId;
+    this.locale = locale;
+  }
+};
+var CliffMissingMetadataError = class extends CliffI18nError {
+  entryId;
+  fields;
+  constructor(entryId, fields, detail = "") {
+    super(
+      `entry ${entryId} is missing required CLIFF field${fields.length === 1 ? "" : "s"} ${fields.map((field) => `"${field}"`).join(", ")}${detail ? "; " + detail : ""}`
+    );
+    this.name = "CliffMissingMetadataError";
+    this.entryId = entryId;
+    this.fields = fields;
+  }
+};
+var CliffIcuError = class extends CliffI18nError {
+  messageText;
+  constructor(messageText, detail) {
+    super(`invalid ICU message: ${detail}`);
+    this.name = "CliffIcuError";
+    this.messageText = messageText;
+  }
+};
+
+// src/types.ts
+var TYPE = {
+  noun: "noun",
+  verb: "verb",
+  adjective: "adjective",
+  adverb: "adverb",
+  pronoun: "pronoun",
+  numeral: "numeral",
+  preposition: "preposition",
+  conjunction: "conjunction",
+  particle: "particle",
+  interjection: "interjection",
+  "proper-noun": "proper-noun",
+  "noun-phrase": "noun-phrase",
+  "verb-phrase": "verb-phrase",
+  "adjective-phrase": "adjective-phrase",
+  "adverb-phrase": "adverb-phrase",
+  "fixed-phrase": "fixed-phrase",
+  idiom: "idiom",
+  sentence: "sentence",
+  description: "description",
+  narration: "narration",
+  dialogue: "dialogue",
+  monologue: "monologue",
+  prompt: "prompt",
+  label: "label",
+  subtitle: "subtitle",
+  "accessibility-cue": "accessibility-cue"
+};
+var EMOTION = {
+  neutral: "neutral",
+  objective: "objective",
+  mechanical: "mechanical",
+  joyful: "joyful",
+  sad: "sad",
+  angry: "angry",
+  fearful: "fearful",
+  surprised: "surprised",
+  curious: "curious",
+  disgusted: "disgusted",
+  anxious: "anxious",
+  calm: "calm",
+  playful: "playful",
+  serious: "serious",
+  urgent: "urgent",
+  romantic: "romantic",
+  hopeful: "hopeful",
+  grateful: "grateful",
+  formal: "formal",
+  informal: "informal",
+  polite: "polite",
+  rude: "rude",
+  nostalgic: "nostalgic"
+};
+var STATUS = {
+  initial: "initial",
+  translated: "translated",
+  reviewed: "reviewed",
+  final: "final"
+};
+var VARIANT = {
+  standard: "standard",
+  glossary: "glossary"
+};
+var STATUS_ORDER = ["initial", "translated", "reviewed", "final"];
+
+// src/vocabulary.ts
+var import_core = require("@cliff-format/core");
+function isTypeTag(value) {
+  return import_core.TYPE_TAGS.has(value);
+}
+function isEmotionTag(value) {
+  return import_core.EMOTION_TAGS.has(value);
+}
+function isStatusTag(value) {
+  return import_core.STATUS_TAGS.has(value);
+}
+function isVariantTag(value) {
+  return import_core.VARIANT_TAGS.has(value);
+}
+function assertTypeTag(value) {
+  if (!isTypeTag(value)) {
+    throw new TypeError(`invalid CLIFF type tag "${value}"`);
+  }
+  return value;
+}
+function assertEmotionTag(value) {
+  if (!isEmotionTag(value)) {
+    throw new TypeError(`invalid CLIFF emotion tag "${value}"`);
+  }
+  return value;
+}
+function assertStatusTag(value) {
+  if (!isStatusTag(value)) {
+    throw new TypeError(`invalid CLIFF status tag "${value}"`);
+  }
+  return value;
+}
+function assertVariantTag(value) {
+  if (!isVariantTag(value)) {
+    throw new TypeError(`invalid CLIFF variant tag "${value}"`);
+  }
+  return value;
+}
+
+// src/status.ts
+var STATUS_TRANSITIONS = {
+  initial: ["translated"],
+  translated: ["reviewed", "translated"],
+  reviewed: ["final", "translated"],
+  final: ["translated"]
+};
+function statusOf(entry) {
+  const value = entry.status ?? "";
+  return isStatusTag(value) ? value : "initial";
+}
+function canTransitionStatus(from, to) {
+  return STATUS_TRANSITIONS[from].includes(to);
+}
+function reconcileEntryStatus(entry, previous = {}) {
+  if (previous.explicit !== void 0) return previous.explicit;
+  const current = statusOf(entry);
+  if (entry.target === void 0) return "initial";
+  if (current === "initial") return "translated";
+  const sourceChanged = previous.source !== void 0 && previous.source !== entry.source;
+  if (sourceChanged) return "translated";
+  const targetChanged = previous.target !== void 0 && previous.target !== entry.target;
+  if (targetChanged && (current === "reviewed" || current === "final")) {
+    return "translated";
+  }
+  return current;
+}
+function nextStatuses(status) {
+  return STATUS_TRANSITIONS[status];
+}
+function statusOrder() {
+  return STATUS_ORDER;
+}
+
+// src/builder.ts
+function normalizeEmotion(tags) {
+  const out = [];
+  for (const tag of tags) {
+    if (Array.isArray(tag)) {
+      for (const item of tag) out.push(assertEmotionTag(item));
+    } else {
+      out.push(assertEmotionTag(tag));
+    }
+  }
+  return out;
+}
+function sameEmotion(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((tag, index) => tag === right[index]);
+}
+var MessageBuilderImpl = class {
+  constructor(i18n, scope, entryIdInput) {
+    this.i18n = i18n;
+    this.scope = scope;
+    this.entryIdInput = entryIdInput;
+  }
+  i18n;
+  scope;
+  entryIdInput;
+  sourceText;
+  sourceParams = {};
+  targetText;
+  targetParams = {};
+  extraParams = {};
+  typeTag;
+  inheritType = false;
+  emotionTags = [];
+  statusTag;
+  contextText;
+  maxWidthCells;
+  referencePaths = [];
+  reviewerName;
+  extensionMap = {};
+  localeOverride;
+  source(text, params = {}) {
+    if (typeof text !== "string") throw new TypeError("source text must be a string");
+    this.sourceText = text;
+    this.sourceParams = { ...this.sourceParams, ...params };
+    return this;
+  }
+  type(tag) {
+    this.typeTag = assertTypeTag(tag);
+    this.inheritType = false;
+    return this;
+  }
+  typeFromGroup() {
+    if (this.sourceText === void 0) {
+      throw new CliffI18nError(".typeFromGroup() must be called after .source()");
+    }
+    if (this.typeTag !== void 0) {
+      throw new CliffI18nError(".typeFromGroup() cannot be used after .type()");
+    }
+    this.inheritType = true;
+    return this;
+  }
+  emotion(...tags) {
+    this.emotionTags = normalizeEmotion(tags);
+    return this;
+  }
+  context(text) {
+    this.contextText = text;
+    return this;
+  }
+  maxWidth(cells) {
+    if (!Number.isInteger(cells) || cells <= 0) {
+      throw new TypeError("max-width must be a positive integer");
+    }
+    this.maxWidthCells = cells;
+    return this;
+  }
+  reference(...paths) {
+    this.referencePaths = [...this.referencePaths, ...paths];
+    return this;
+  }
+  reviewer(name) {
+    this.reviewerName = name;
+    return this;
+  }
+  extension(name, value) {
+    if (!name.startsWith("x-")) {
+      throw new TypeError(`extension name "${name}" must start with "x-"`);
+    }
+    this.extensionMap[name] = value;
+    return this;
+  }
+  target(text, params = {}) {
+    this.targetText = text;
+    this.targetParams = { ...this.targetParams, ...params };
+    return this;
+  }
+  status(tag) {
+    this.statusTag = assertStatusTag(tag);
+    return this;
+  }
+  locale(tag) {
+    this.localeOverride = tag;
+    return this;
+  }
+  params(params) {
+    this.extraParams = { ...this.extraParams, ...params };
+    return this;
+  }
+  count(value) {
+    this.extraParams = { ...this.extraParams, count: value, n: value };
+    return this;
+  }
+  activeLocale() {
+    return this.localeOverride ?? this.i18n.getLocale();
+  }
+  resolved() {
+    return this.i18n.resolve(this.entryIdInput, this.scope);
+  }
+  recordFor(resolved) {
+    return this.i18n.recordFor(resolved.canonical, this.activeLocale());
+  }
+  mergedParams(params) {
+    return {
+      ...this.i18n.defaultParams,
+      ...this.sourceParams,
+      ...this.targetParams,
+      ...this.extraParams,
+      ...params
+    };
+  }
+  diagnose(code, severity, message, resolved) {
+    this.i18n.diagnose({
+      code,
+      severity,
+      message,
+      ...resolved === void 0 ? {} : { entryId: resolved.canonical },
+      locale: this.activeLocale(),
+      namespace: this.scope.namespace,
+      clan: this.scope.clan,
+      ...this.scope.group === void 0 ? {} : { group: this.scope.group }
+    });
+  }
+  requireEffectiveType(resolved) {
+    if (this.typeTag !== void 0) return this.typeTag;
+    if (!this.inheritType) return void 0;
+    const group = this.i18n.getCatalog().findGroup(resolved.namespace, resolved.clan, resolved.group);
+    if (group?.type === void 0) {
+      throw new CliffMissingMetadataError(
+        resolved.canonical,
+        ["type"],
+        `group [${resolved.group}] has no type; add .type(TYPE...) or declare type on the group`
+      );
+    }
+    return group.type;
+  }
+  ensureAuthoringMetadata(resolved) {
+    if (this.sourceText === void 0) return;
+    if (this.typeTag !== void 0) return;
+    if (this.inheritType) {
+      this.requireEffectiveType(resolved);
+      return;
+    }
+    throw new CliffMissingMetadataError(
+      resolved.canonical,
+      ["type"],
+      "add .type(TYPE...) or .typeFromGroup()"
+    );
+  }
+  groupEmotion(resolved) {
+    const group = this.i18n.getCatalog().findGroup(resolved.namespace, resolved.clan, resolved.group);
+    return group?.emotion ? [...group.emotion] : [];
+  }
+  requireEmotionIfConfigured(resolved, effectiveType2) {
+    const requirement = this.i18n.requireEmotion;
+    if (requirement === false) return;
+    if (this.emotionTags.length > 0) return;
+    const groupEmotion = this.groupEmotion(resolved);
+    if (groupEmotion.length > 0) return;
+    if (requirement === true) {
+      throw new CliffMissingMetadataError(
+        resolved.canonical,
+        ["emotion"],
+        "requireEmotion is enabled; add .emotion(...) or declare emotion on the group"
+      );
+    }
+    if (effectiveType2 !== void 0 && requirement.includes(effectiveType2)) {
+      throw new CliffMissingMetadataError(
+        resolved.canonical,
+        ["emotion"],
+        `requireEmotion requires an explicit emotion for type "${effectiveType2}"`
+      );
+    }
+  }
+  createDraft(resolved) {
+    const sourceLanguage = this.i18n.getSourceLanguage();
+    const targetLanguage = this.activeLocale();
+    const effectiveType2 = this.requireEffectiveType(resolved);
+    this.requireEmotionIfConfigured(resolved, effectiveType2);
+    const status = this.statusTag ?? (this.targetText === void 0 ? "initial" : "translated");
+    if (status !== "initial" && this.targetText === void 0) {
+      throw new CliffMissingMetadataError(
+        resolved.canonical,
+        ["target"],
+        `status "${status}" requires a target field`
+      );
+    }
+    const record = this.i18n.getCatalog().addDraft(
+      {
+        namespace: resolved.namespace,
+        clan: resolved.clan,
+        group: resolved.group,
+        id: resolved.id,
+        sourceLanguage,
+        targetLanguage
+      },
+      {
+        ...this.sourceText === void 0 ? {} : { source: this.sourceText },
+        ...this.targetText === void 0 ? {} : { target: this.targetText },
+        ...this.typeTag === void 0 ? {} : { type: this.typeTag },
+        emotion: this.emotionTags,
+        status,
+        ...this.contextText === void 0 ? {} : { context: this.contextText },
+        ...this.maxWidthCells === void 0 ? {} : { maxWidth: this.maxWidthCells },
+        ...this.referencePaths.length === 0 ? {} : { reference: this.referencePaths },
+        ...this.reviewerName === void 0 ? {} : { reviewer: this.reviewerName },
+        ...Object.keys(this.extensionMap).length === 0 ? {} : { extensions: this.extensionMap }
+      }
+    );
+    this.diagnose("draft-created", "info", `created CLIFF draft "${resolved.canonical}"`, resolved);
+    return record;
+  }
+  checkWidth(text, maxWidth, resolved, locale) {
+    const policy = this.i18n.enforceMaxWidth;
+    if (policy === "off") return;
+    const cells = (0, import_core2.displayWidth)(text);
+    if (cells <= maxWidth) return;
+    const message = `rendered display width ${cells} cells exceeds max-width ${maxWidth} for "${resolved.canonical}" in "${locale}"`;
+    if (policy === "error") {
+      this.diagnose("width-exceeded", "error", message, resolved);
+      throw new CliffI18nError(message);
+    }
+    this.diagnose("width-exceeded", "warning", message, resolved);
+  }
+  renderRecord(record, resolved, params, parts) {
+    const target = this.targetText ?? record.target;
+    const template = target ?? record.source;
+    const formatLocale = target !== void 0 ? record.locale : record.sourceLanguage;
+    const values = this.mergedParams(params);
+    const maxWidth = this.maxWidthCells ?? record.maxWidth;
+    if (parts) {
+      const result = this.i18n.formatToParts(template, values, { locale: formatLocale });
+      if (maxWidth !== void 0) {
+        const text2 = result.filter((part) => part.type !== "markup").map((part) => part.type === "literal" ? part.value : part.value).join("");
+        this.checkWidth(text2, maxWidth, resolved, formatLocale);
+      }
+      return result;
+    }
+    const text = this.i18n.format(template, values, { locale: formatLocale });
+    if (maxWidth !== void 0) this.checkWidth(text, maxWidth, resolved, formatLocale);
+    return text;
+  }
+  expectationDiagnostics(record, resolved) {
+    if (this.sourceText !== void 0 && this.sourceText !== record.source) {
+      this.diagnose(
+        "source-mismatch",
+        "warning",
+        `source in CLIFF differs from .source(); CLIFF keeps "${record.source}"`,
+        resolved
+      );
+    }
+    if (this.typeTag !== void 0 && record.type !== this.typeTag) {
+      this.diagnose(
+        "type-mismatch",
+        "warning",
+        `entry type is "${record.type ?? ""}", not "${this.typeTag}"`,
+        resolved
+      );
+    }
+    if (this.emotionTags.length > 0 && !sameEmotion(this.emotionTags, record.emotion)) {
+      this.diagnose(
+        "emotion-mismatch",
+        "warning",
+        `entry emotion is [${record.emotion.join(", ")}], not [${this.emotionTags.join(", ")}]`,
+        resolved
+      );
+    }
+  }
+  missing(resolved) {
+    const message = `missing CLIFF entry "${resolved.canonical}" for locale "${this.activeLocale()}"`;
+    this.diagnose("missing-entry", "warning", message, resolved);
+    const behavior = this.i18n.missing;
+    if (behavior === "throw") {
+      throw new CliffMissingEntryError(resolved.canonical, this.activeLocale());
+    }
+    if (behavior === "empty") return "";
+    if (behavior === "source") return this.sourceText ?? "";
+    if (typeof this.entryIdInput === "string") return this.entryIdInput;
+    return resolved.canonical;
+  }
+  render(params) {
+    const resolved = this.resolved();
+    const record = this.recordFor(resolved);
+    if (this.sourceText === void 0) {
+      if (record === void 0) return this.missing(resolved);
+      this.expectationDiagnostics(record, resolved);
+      return this.renderRecord(record, resolved, params, false);
+    }
+    this.ensureAuthoringMetadata(resolved);
+    if (record !== void 0) {
+      this.expectationDiagnostics(record, resolved);
+      return this.renderRecord(record, resolved, params, false);
+    }
+    const draft = this.createDraft(resolved);
+    return this.renderRecord(draft, resolved, params, false);
+  }
+  renderToParts(params) {
+    const resolved = this.resolved();
+    const record = this.recordFor(resolved);
+    if (this.sourceText === void 0) {
+      if (record === void 0) {
+        const text = this.missing(resolved);
+        return [{ type: "literal", value: text }];
+      }
+      this.expectationDiagnostics(record, resolved);
+      return this.renderRecord(record, resolved, params, true);
+    }
+    this.ensureAuthoringMetadata(resolved);
+    if (record !== void 0) {
+      this.expectationDiagnostics(record, resolved);
+      return this.renderRecord(record, resolved, params, true);
+    }
+    const draft = this.createDraft(resolved);
+    return this.renderRecord(draft, resolved, params, true);
+  }
+  meta() {
+    const resolved = this.resolved();
+    const record = this.recordFor(resolved);
+    const source = this.sourceText ?? record?.source ?? "";
+    const target = this.targetText ?? record?.target;
+    const type = this.typeTag ?? record?.type;
+    const emotion = this.emotionTags.length > 0 ? [...this.emotionTags] : record?.emotion ?? [];
+    const status = this.statusTag ?? record?.status;
+    const context = this.contextText ?? record?.context;
+    const maxWidth = this.maxWidthCells ?? record?.maxWidth;
+    const reference = this.referencePaths.length > 0 ? [...this.referencePaths] : record?.reference ?? [];
+    const reviewer = this.reviewerName ?? record?.reviewer;
+    return {
+      entryId: resolved.canonical,
+      namespace: resolved.namespace,
+      clan: resolved.clan,
+      group: resolved.group,
+      id: resolved.id,
+      locale: this.activeLocale(),
+      sourceLanguage: record?.sourceLanguage ?? this.i18n.getSourceLanguage(),
+      targetLanguage: record?.locale ?? this.activeLocale(),
+      variant: record?.variant ?? "standard",
+      source,
+      ...target === void 0 ? {} : { target },
+      ...type === void 0 ? {} : { type },
+      emotion,
+      ...status === void 0 ? {} : { status },
+      ...context === void 0 ? {} : { context },
+      ...maxWidth === void 0 ? {} : { maxWidth },
+      reference,
+      ...reviewer === void 0 ? {} : { reviewer },
+      extensions: record?.extensions ?? { ...this.extensionMap }
+    };
+  }
+  entry() {
+    const resolved = this.resolved();
+    return this.recordFor(resolved)?.entry;
+  }
+  commit(options = {}) {
+    const resolved = this.resolved();
+    const existing = this.recordFor(resolved);
+    if (existing === void 0) {
+      this.ensureAuthoringMetadata(resolved);
+      const draft = this.createDraft(resolved);
+      this.validateDocument(draft);
+      return this;
+    }
+    if (options.overwrite === true) {
+      this.ensureAuthoringMetadata(resolved);
+      this.applyOverwrite(existing);
+    } else if (this.targetText !== void 0) {
+      const previous = {
+        ...existing.entry.source === void 0 ? {} : { source: existing.entry.source },
+        ...existing.entry.target === void 0 ? {} : { target: existing.entry.target },
+        ...this.statusTag === void 0 ? {} : { explicit: this.statusTag }
+      };
+      existing.entry.target = this.targetText;
+      existing.entry.status = reconcileEntryStatus(existing.entry, previous);
+    } else {
+      this.ensureAuthoringMetadata(resolved);
+    }
+    this.validateDocument(existing);
+    return this;
+  }
+  applyOverwrite(record) {
+    const entry = record.entry;
+    const previous = {
+      ...entry.source === void 0 ? {} : { source: entry.source },
+      ...entry.target === void 0 ? {} : { target: entry.target },
+      ...this.statusTag === void 0 ? {} : { explicit: this.statusTag }
+    };
+    if (this.sourceText !== void 0) entry.source = this.sourceText;
+    if (this.targetText !== void 0) entry.target = this.targetText;
+    if (this.typeTag !== void 0) entry.type = this.typeTag;
+    if (this.emotionTags.length > 0) entry.emotion = [...this.emotionTags];
+    if (this.contextText !== void 0) entry.context = this.contextText;
+    if (this.maxWidthCells !== void 0) entry.maxWidth = this.maxWidthCells;
+    if (this.referencePaths.length > 0) entry.reference = [...this.referencePaths];
+    if (this.reviewerName !== void 0) entry.reviewer = this.reviewerName;
+    if (Object.keys(this.extensionMap).length > 0) {
+      entry.extensions = { ...entry.extensions, ...this.extensionMap };
+    }
+    entry.status = reconcileEntryStatus(entry, previous);
+  }
+  validateDocument(record) {
+    const issues = (0, import_core2.validateDocument)(record.document);
+    if ((0, import_core2.hasErrors)(issues)) {
+      throw new import_core2.CliffValidationError(issues, record.document.corrections);
+    }
+  }
+  width(params) {
+    return (0, import_core2.displayWidth)(this.render(params));
+  }
+  fits(params) {
+    const resolved = this.resolved();
+    const record = this.recordFor(resolved);
+    const maxWidth = this.maxWidthCells ?? record?.maxWidth;
+    if (maxWidth === void 0) return true;
+    return this.width(params) <= maxWidth;
+  }
+  toString() {
+    return this.render();
+  }
+};
+function createT(i18n, scope) {
+  const callable = (entryId, params) => {
+    const builder = new MessageBuilderImpl(i18n, scope, entryId);
+    if (params === void 0) {
+      return builder;
+    }
+    return builder.params(params).render();
+  };
+  const fn = callable;
+  fn.render = (entryId, params) => new MessageBuilderImpl(i18n, scope, entryId).render(params);
+  fn.renderToParts = (entryId, params) => new MessageBuilderImpl(i18n, scope, entryId).renderToParts(params);
+  fn.has = (entryId) => {
+    const resolved = i18n.resolve(entryId, scope);
+    return resolved.exists && i18n.recordFor(resolved.canonical, i18n.getLocale()) !== void 0;
+  };
+  fn.entry = (entryId) => {
+    const resolved = i18n.resolve(entryId, scope);
+    return i18n.recordFor(resolved.canonical, i18n.getLocale())?.entry;
+  };
+  fn.meta = (entryId) => new MessageBuilderImpl(i18n, scope, entryId).meta();
+  fn.entryIds = () => i18n.getCatalog().entryIds(scope);
+  return fn;
+}
+
+// src/catalog.ts
+var import_core3 = require("@cliff-format/core");
+function normalizeLocale(tag) {
+  return tag.toLowerCase();
+}
+function localeVariants(tag) {
+  const parts = tag.split("-").filter((part) => part.length > 0);
+  const variants = [];
+  for (let length = parts.length; length >= 1; length--) {
+    variants.push(parts.slice(0, length).join("-"));
+  }
+  return variants;
+}
+function addSuffix(map, suffix, canonical) {
+  if (suffix.length === 0) return;
+  const existing = map.get(suffix);
+  if (existing === void 0) {
+    map.set(suffix, /* @__PURE__ */ new Set([canonical]));
+  } else {
+    existing.add(canonical);
+  }
+}
+function recordFrom(document, group, entry) {
+  const namespace = document.header.namespace;
+  const clan = document.header.clan;
+  const groupPath = group.path;
+  const canonical = (0, import_core3.canonicalId)(namespace, clan, groupPath, entry.id);
+  const type = (0, import_core3.effectiveType)(entry, group);
+  const context = (0, import_core3.effectiveContext)(entry, group);
+  const maxWidth = (0, import_core3.effectiveMaxWidth)(entry, group);
+  return {
+    canonical,
+    namespace,
+    clan,
+    group: groupPath,
+    id: entry.id,
+    locale: document.header.targetLanguage,
+    sourceLanguage: document.header.sourceLanguage,
+    document,
+    groupRef: group,
+    entry,
+    variant: document.header.variant,
+    source: entry.source ?? "",
+    ...entry.target === void 0 ? {} : { target: entry.target },
+    ...type === void 0 ? {} : { type },
+    emotion: (0, import_core3.effectiveEmotion)(entry, group),
+    ...entry.status === void 0 ? {} : { status: entry.status },
+    ...context === void 0 ? {} : { context },
+    ...maxWidth === void 0 ? {} : { maxWidth },
+    reference: [...entry.reference],
+    ...entry.reviewer === void 0 ? {} : { reviewer: entry.reviewer },
+    extensions: { ...entry.extensions },
+    ...document.path === void 0 ? {} : { filePath: document.path }
+  };
+}
+var Catalog = class {
+  defaultGroup;
+  aliases;
+  documentsList = [];
+  byLocale = /* @__PURE__ */ new Map();
+  byCanonical = /* @__PURE__ */ new Map();
+  suffixMap = /* @__PURE__ */ new Map();
+  namespaceSet = /* @__PURE__ */ new Set();
+  clanSet = /* @__PURE__ */ new Set();
+  groupSet = /* @__PURE__ */ new Set();
+  localeSet = /* @__PURE__ */ new Set();
+  sourceLanguageSet = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.defaultGroup = options.defaultGroup ?? "general";
+    this.aliases = options.aliases ?? {};
+  }
+  get knownNamespaces() {
+    return this.namespaceSet;
+  }
+  get knownClans() {
+    return this.clanSet;
+  }
+  get documents() {
+    return this.documentsList;
+  }
+  get sourceLanguages() {
+    return [...this.sourceLanguageSet];
+  }
+  addDocument(document) {
+    const locale = document.header.targetLanguage;
+    const localeTag = normalizeLocale(locale);
+    let localeMap = this.byLocale.get(localeTag);
+    if (localeMap === void 0) {
+      localeMap = /* @__PURE__ */ new Map();
+      this.byLocale.set(localeTag, localeMap);
+    }
+    const added = [];
+    for (const group of document.groups) {
+      for (const entry of group.entries) {
+        const record = recordFrom(document, group, entry);
+        if (localeMap.has(record.canonical)) {
+          throw new CliffDuplicateEntryError(record.canonical, locale);
+        }
+        this.indexRecord(record, localeMap);
+        added.push(record);
+      }
+    }
+    this.documentsList.push(document);
+    this.namespaceSet.add(document.header.namespace);
+    this.clanSet.add(document.header.clan);
+    this.localeSet.add(locale);
+    if (document.header.sourceLanguage.length > 0) {
+      this.sourceLanguageSet.add(document.header.sourceLanguage);
+    }
+    return added;
+  }
+  addDraft(parts, draft) {
+    const document = this.ensureDocument(parts);
+    let group = document.groups.find((candidate) => candidate.path === parts.group);
+    if (group === void 0) {
+      group = {
+        path: parts.group,
+        line: 0,
+        emotion: [],
+        entries: [],
+        extensions: (0, import_core3.createExtensions)()
+      };
+      document.groups.push(group);
+      this.groupSet.add(parts.group);
+    }
+    const entry = {
+      id: parts.id,
+      line: 0,
+      emotion: draft.emotion ? [...draft.emotion] : [],
+      reference: draft.reference ? [...draft.reference] : [],
+      extensions: draft.extensions ? { ...draft.extensions } : (0, import_core3.createExtensions)()
+    };
+    if (draft.source !== void 0) entry.source = draft.source;
+    if (draft.target !== void 0) entry.target = draft.target;
+    if (draft.type !== void 0) entry.type = draft.type;
+    if (draft.status !== void 0) entry.status = draft.status;
+    if (draft.context !== void 0) entry.context = draft.context;
+    if (draft.maxWidth !== void 0) entry.maxWidth = draft.maxWidth;
+    if (draft.reviewer !== void 0) entry.reviewer = draft.reviewer;
+    const canonical = (0, import_core3.canonicalId)(parts.namespace, parts.clan, parts.group, parts.id);
+    const localeMap = this.byLocale.get(normalizeLocale(parts.targetLanguage));
+    if (localeMap?.has(canonical) === true) {
+      throw new CliffDuplicateEntryError(canonical, parts.targetLanguage);
+    }
+    group.entries.push(entry);
+    const record = recordFrom(document, group, entry);
+    if (localeMap === void 0) {
+      const created = /* @__PURE__ */ new Map();
+      this.byLocale.set(normalizeLocale(parts.targetLanguage), created);
+      this.indexRecord(record, created);
+    } else {
+      this.indexRecord(record, localeMap);
+    }
+    this.localeSet.add(parts.targetLanguage);
+    this.sourceLanguageSet.add(parts.sourceLanguage);
+    return record;
+  }
+  ensureDocument(parts) {
+    const existing = this.documentsList.find(
+      (document2) => document2.header.namespace === parts.namespace && document2.header.clan === parts.clan && normalizeLocale(document2.header.targetLanguage) === normalizeLocale(parts.targetLanguage)
+    );
+    if (existing !== void 0) return existing;
+    const document = (0, import_core3.createDocument)("1.1");
+    document.header.namespace = parts.namespace;
+    document.header.clan = parts.clan;
+    document.header.sourceLanguage = parts.sourceLanguage;
+    document.header.targetLanguage = parts.targetLanguage;
+    document.header.variant = "standard";
+    this.documentsList.push(document);
+    this.namespaceSet.add(parts.namespace);
+    this.clanSet.add(parts.clan);
+    return document;
+  }
+  indexRecord(record, localeMap) {
+    localeMap.set(record.canonical, record);
+    const existing = this.byCanonical.get(record.canonical);
+    if (existing === void 0) {
+      this.byCanonical.set(record.canonical, [record]);
+    } else {
+      existing.push(record);
+    }
+    this.namespaceSet.add(record.namespace);
+    this.clanSet.add(record.clan);
+    this.groupSet.add(record.group);
+    addSuffix(this.suffixMap, `${record.clan}.${record.group}.${record.id}`, record.canonical);
+    addSuffix(this.suffixMap, `${record.group}.${record.id}`, record.canonical);
+    const lastGroup = record.group.split(".").at(-1);
+    if (lastGroup !== void 0) {
+      addSuffix(this.suffixMap, `${lastGroup}.${record.id}`, record.canonical);
+    }
+    addSuffix(this.suffixMap, record.id, record.canonical);
+  }
+  hasCanonical(canonical) {
+    return this.byCanonical.has(canonical);
+  }
+  recordForCanonical(canonical) {
+    return this.byCanonical.get(canonical)?.[0];
+  }
+  recordsForCanonical(canonical) {
+    return this.byCanonical.get(canonical) ?? [];
+  }
+  suffixMatches(suffix) {
+    return [...this.suffixMap.get(suffix) ?? []];
+  }
+  record(canonical, locale) {
+    return this.byLocale.get(normalizeLocale(locale))?.get(canonical);
+  }
+  selectRecord(canonical, localeChain, sourceLanguage) {
+    const records = this.byCanonical.get(canonical);
+    if (records === void 0) return void 0;
+    for (const tag of localeChain) {
+      const found = records.find(
+        (record) => normalizeLocale(record.locale) === tag && record.target !== void 0
+      );
+      if (found !== void 0) return found;
+    }
+    for (const tag of localeChain) {
+      const found = records.find((record) => normalizeLocale(record.locale) === tag);
+      if (found !== void 0) return found;
+    }
+    if (sourceLanguage !== void 0) {
+      const found = records.find(
+        (record) => normalizeLocale(record.locale) === normalizeLocale(sourceLanguage)
+      );
+      if (found !== void 0) return found;
+    }
+    return records[0];
+  }
+  localeChain(locale, fallbacks = [], sourceLanguage) {
+    const tags = [];
+    const add = (tag) => {
+      for (const variant of localeVariants(tag)) {
+        const normalized = normalizeLocale(variant);
+        if (normalized.length > 0 && !tags.includes(normalized)) tags.push(normalized);
+      }
+    };
+    add(locale);
+    for (const fallback of fallbacks) add(fallback);
+    if (sourceLanguage !== void 0) add(sourceLanguage);
+    return tags;
+  }
+  namespaces() {
+    return [...this.namespaceSet].sort();
+  }
+  clans(namespace) {
+    if (namespace === void 0) return [...this.clanSet].sort();
+    const clans = /* @__PURE__ */ new Set();
+    for (const records of this.byCanonical.values()) {
+      for (const record of records) {
+        if (record.namespace === namespace) clans.add(record.clan);
+      }
+    }
+    return [...clans].sort();
+  }
+  groups(scope = {}) {
+    const groups = /* @__PURE__ */ new Set();
+    for (const records of this.byCanonical.values()) {
+      for (const record of records) {
+        if (scope.namespace !== void 0 && record.namespace !== scope.namespace) continue;
+        if (scope.clan !== void 0 && record.clan !== scope.clan) continue;
+        if (scope.group !== void 0 && scope.group.length > 0 && !(record.group === scope.group || record.group.startsWith(`${scope.group}.`))) {
+          continue;
+        }
+        groups.add(record.group);
+      }
+    }
+    return [...groups].sort();
+  }
+  entryIds(scope = {}) {
+    const entryIds = /* @__PURE__ */ new Set();
+    for (const records of this.byCanonical.values()) {
+      for (const record of records) {
+        if (scope.namespace !== void 0 && record.namespace !== scope.namespace) continue;
+        if (scope.clan !== void 0 && record.clan !== scope.clan) continue;
+        if (scope.group !== void 0 && scope.group.length > 0 && !(record.group === scope.group || record.group.startsWith(`${scope.group}.`))) {
+          continue;
+        }
+        entryIds.add(record.canonical);
+      }
+    }
+    return [...entryIds].sort();
+  }
+  allRecords() {
+    const records = [];
+    for (const group of this.byCanonical.values()) records.push(...group);
+    return records;
+  }
+  query(options = {}) {
+    const statuses = options.status === void 0 ? void 0 : new Set(Array.isArray(options.status) ? options.status : [options.status]);
+    return this.allRecords().filter((record) => {
+      if (options.namespace !== void 0 && record.namespace !== options.namespace) return false;
+      if (options.clan !== void 0 && record.clan !== options.clan) return false;
+      if (options.group !== void 0 && options.group.length > 0 && !(record.group === options.group || record.group.startsWith(`${options.group}.`))) {
+        return false;
+      }
+      if (options.locale !== void 0 && options.locale !== "all" && normalizeLocale(record.locale) !== normalizeLocale(options.locale)) {
+        return false;
+      }
+      if (statuses !== void 0 && !statuses.has(statusOf(record.entry))) return false;
+      if (options.target === "present" && record.target === void 0) return false;
+      if (options.target === "missing" && record.target !== void 0) return false;
+      return true;
+    });
+  }
+  untranslated(options = {}) {
+    return this.query(options).filter(
+      (record) => record.target === void 0 || statusOf(record.entry) === "initial"
+    );
+  }
+  byStatus(status, options = {}) {
+    return this.query({ ...options, status });
+  }
+  statusCounts(options = {}) {
+    const counts = {
+      initial: 0,
+      translated: 0,
+      reviewed: 0,
+      final: 0
+    };
+    for (const record of this.query(options)) counts[statusOf(record.entry)]++;
+    return counts;
+  }
+  locales() {
+    return [...this.localeSet].sort();
+  }
+  findGroup(namespace, clan, groupPath) {
+    for (const document of this.documentsList) {
+      if (document.header.namespace !== namespace || document.header.clan !== clan) continue;
+      const group = document.groups.find((candidate) => candidate.path === groupPath);
+      if (group !== void 0) return group;
+    }
+    return void 0;
+  }
+  files(options = {}) {
+    const files = [];
+    const used = /* @__PURE__ */ new Set();
+    const layout = options.layout ?? "folder";
+    for (const document of this.documentsList) {
+      const header = document.header;
+      let filePath = document.path;
+      if (filePath === void 0 || filePath.length === 0) {
+        filePath = layout === "flat" ? `${header.clan}.${header.targetLanguage}.cliff` : `${header.targetLanguage}/${header.clan}.cliff`;
+      }
+      if (used.has(filePath)) {
+        throw new CliffI18nError(`duplicate CLIFF output path "${filePath}"`);
+      }
+      used.add(filePath);
+      files.push({
+        filePath,
+        namespace: header.namespace,
+        clan: header.clan,
+        locale: header.targetLanguage,
+        text: (0, import_core3.serialize)(document),
+        document
+      });
+    }
+    return files;
+  }
+  toCliff(options = {}) {
+    const files = this.files(options);
+    if (files.length === 0) return "";
+    if (files.length > 1) {
+      throw new CliffI18nError(
+        `${files.length} CLIFF documents are loaded; use files() and write each one separately`
+      );
+    }
+    const first = files[0];
+    if (first === void 0) return "";
+    return first.text;
+  }
+  validate() {
+    const issues = [];
+    for (const document of this.documentsList) {
+      issues.push(...(0, import_core3.validateDocument)(document));
+    }
+    return issues;
+  }
+};
+function assertCatalogParts(parts) {
+  if (!(0, import_core3.isName)(parts.namespace)) throw new CliffI18nError(`invalid namespace "${parts.namespace}"`);
+  if (!(0, import_core3.isName)(parts.clan)) throw new CliffI18nError(`invalid clan "${parts.clan}"`);
+  if (!(0, import_core3.isName)(parts.id)) throw new CliffI18nError(`invalid entry id "${parts.id}"`);
+  for (const segment of parts.group.split(".")) {
+    if (!(0, import_core3.isName)(segment)) {
+      throw new CliffI18nError(`invalid group path "${parts.group}"`);
+    }
+  }
+}
+
+// src/entry-id.ts
+var import_core4 = require("@cliff-format/core");
+function joinCanonical(namespace, clan, group, id) {
+  return [namespace, clan, group, id].filter((part) => part.length > 0).join(".");
+}
+function assertScope(scope) {
+  if (!(0, import_core4.isName)(scope.namespace)) {
+    throw new CliffScopeError(
+      `namespace "${scope.namespace}" is not a valid CLIFF name (A-Z a-z 0-9 _ -)`,
+      scope
+    );
+  }
+  if (!(0, import_core4.isName)(scope.clan)) {
+    throw new CliffScopeError(
+      `clan "${scope.clan}" is not a valid CLIFF name (A-Z a-z 0-9 _ -)`,
+      scope
+    );
+  }
+  if (scope.group !== void 0 && scope.group.length > 0) {
+    for (const segment of scope.group.split(".")) {
+      if (!(0, import_core4.isName)(segment)) {
+        throw new CliffScopeError(
+          `group path "${scope.group}" contains invalid segment "${segment}"`,
+          scope
+        );
+      }
+    }
+  }
+}
+function applyAlias(raw, aliases) {
+  let current = raw;
+  const seen = /* @__PURE__ */ new Set();
+  while (Object.hasOwn(aliases, current)) {
+    if (seen.has(current)) {
+      throw new CliffScopeError(`alias cycle while resolving "${raw}"`);
+    }
+    seen.add(current);
+    current = aliases[current];
+  }
+  return current;
+}
+function parseStringEntryId(raw) {
+  const text = raw.trim();
+  if (text.length === 0) {
+    throw new CliffScopeError("entry ID must not be empty");
+  }
+  const colon = /^([A-Za-z0-9_-]+):(.+)$/.exec(text);
+  const namespace = colon?.[1];
+  const body = colon?.[2] ?? text;
+  if (namespace !== void 0 && !(0, import_core4.isName)(namespace)) {
+    throw new CliffScopeError(`namespace "${namespace}" is not a valid CLIFF name`);
+  }
+  const segments = body.split(/[./]/).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    throw new CliffScopeError(`entry ID "${raw}" has no path segments`);
+  }
+  for (const segment of segments) {
+    if (!(0, import_core4.isName)(segment)) {
+      throw new CliffScopeError(
+        `entry ID "${raw}" contains invalid segment "${segment}"; CLIFF names use A-Z a-z 0-9 _ -`
+      );
+    }
+  }
+  return namespace === void 0 ? { raw, segments } : { raw, namespace, segments };
+}
+function candidateEntryIds(parsed, scope) {
+  const joined = parsed.segments.join(".");
+  const out = [];
+  const add = (value) => {
+    if (value.length > 0 && !out.includes(value)) out.push(value);
+  };
+  if (parsed.namespace !== void 0) {
+    add(`${parsed.namespace}.${joined}`);
+    add(`${parsed.namespace}.${scope.clan}.${joined}`);
+    if (scope.group !== void 0 && scope.group.length > 0) {
+      add(`${parsed.namespace}.${scope.clan}.${scope.group}.${joined}`);
+    }
+    return out;
+  }
+  add(joined);
+  add(`${scope.namespace}.${joined}`);
+  add(`${scope.namespace}.${scope.clan}.${joined}`);
+  if (scope.group !== void 0 && scope.group.length > 0) {
+    add(`${scope.namespace}.${scope.clan}.${scope.group}.${joined}`);
+  }
+  return out;
+}
+function partsOfRecord(record) {
+  return {
+    namespace: record.namespace,
+    clan: record.clan,
+    group: record.group,
+    id: record.id,
+    canonical: record.canonical,
+    exists: true
+  };
+}
+function groupPrefixLength(group, prefix) {
+  const groupSegments = group.split(".");
+  const prefixSegments = prefix.split(".").filter((segment) => segment.length > 0);
+  let count = 0;
+  while (count < groupSegments.length && count < prefixSegments.length && groupSegments[count] === prefixSegments[count]) {
+    count++;
+  }
+  return count;
+}
+function chooseByGroup(records, scope) {
+  const prefix = scope.group ?? "";
+  const sorted = [...records].sort((left, right) => {
+    const leftPrefix = prefix.length > 0 ? groupPrefixLength(left.group, prefix) : 0;
+    const rightPrefix = prefix.length > 0 ? groupPrefixLength(right.group, prefix) : 0;
+    if (leftPrefix !== rightPrefix) return rightPrefix - leftPrefix;
+    const leftSegments = left.group.split(".").length;
+    const rightSegments = right.group.split(".").length;
+    if (leftSegments !== rightSegments) return rightSegments - leftSegments;
+    return left.canonical.localeCompare(right.canonical);
+  });
+  return sorted[0];
+}
+function validateGroup(group) {
+  if (group.length === 0) return;
+  for (const segment of group.split(".")) {
+    if (!(0, import_core4.isName)(segment)) {
+      throw new CliffScopeError(`group path "${group}" contains invalid segment "${segment}"`);
+    }
+  }
+}
+function parseAuthoringEntryId(parsed, scope, context) {
+  if (parsed.namespace !== void 0 && parsed.namespace !== scope.namespace) {
+    throw new CliffScopeMismatchError(
+      parsed.raw,
+      scope,
+      `${scope.namespace}.${scope.clan}.<group>.<id>`
+    );
+  }
+  let segments = [...parsed.segments];
+  if (segments[0] === scope.namespace) {
+    segments = segments.slice(1);
+    if (segments[0] === scope.clan) {
+      segments = segments.slice(1);
+    } else if (segments[0] !== void 0 && context.knownClans.has(segments[0])) {
+      throw new CliffScopeMismatchError(
+        parsed.raw,
+        scope,
+        `${scope.namespace}.${scope.clan}.<group>.<id>`
+      );
+    }
+  } else if (segments[0] !== void 0 && context.knownNamespaces.has(segments[0]) && segments[0] !== scope.namespace) {
+    throw new CliffScopeMismatchError(
+      parsed.raw,
+      scope,
+      `${scope.namespace}.${scope.clan}.<group>.<id>`
+    );
+  }
+  if (segments[0] === scope.clan) {
+    segments = segments.slice(1);
+  } else if (segments[0] !== void 0 && context.knownClans.has(segments[0]) && segments[0] !== scope.clan) {
+    throw new CliffScopeMismatchError(
+      parsed.raw,
+      scope,
+      `${scope.namespace}.${scope.clan}.<group>.<id>`
+    );
+  }
+  if (segments.length === 0) {
+    throw new CliffScopeError(`entry ID "${parsed.raw}" has no entry id`);
+  }
+  const id = segments[segments.length - 1];
+  if (!(0, import_core4.isName)(id)) {
+    throw new CliffScopeError(`entry id "${id}" is not a valid CLIFF name`);
+  }
+  const groupSegments = segments.slice(0, -1);
+  let group = groupSegments.length > 0 ? groupSegments.join(".") : scope.group && scope.group.length > 0 ? scope.group : context.defaultGroup;
+  if (scope.group !== void 0 && scope.group.length > 0 && groupSegments.length > 0) {
+    group = `${scope.group}.${groupSegments.join(".")}`;
+  }
+  if (group.length === 0) group = context.defaultGroup;
+  validateGroup(group);
+  return {
+    namespace: scope.namespace,
+    clan: scope.clan,
+    group,
+    id,
+    canonical: joinCanonical(scope.namespace, scope.clan, group, id),
+    exists: false
+  };
+}
+function resolveObjectEntryId(input, scope, context) {
+  const namespace = input.namespace ?? scope.namespace;
+  const clan = input.clan ?? scope.clan;
+  const group = input.group && input.group.length > 0 ? input.group : scope.group && scope.group.length > 0 ? scope.group : context.defaultGroup;
+  if (namespace !== scope.namespace || clan !== scope.clan) {
+    throw new CliffScopeMismatchError(
+      input.id,
+      scope,
+      `${scope.namespace}.${scope.clan}.<group>.<id>`
+    );
+  }
+  if (!(0, import_core4.isName)(input.id)) {
+    throw new CliffScopeError(`entry id "${input.id}" is not a valid CLIFF name`);
+  }
+  validateGroup(group);
+  const canonical = joinCanonical(namespace, clan, group, input.id);
+  const record = context.recordForCanonical(canonical);
+  if (record !== void 0) return partsOfRecord(record);
+  return {
+    namespace,
+    clan,
+    group,
+    id: input.id,
+    canonical,
+    exists: context.hasCanonical(canonical)
+  };
+}
+function resolveEntryId(input, scope, context, strictEntryIds = true) {
+  assertScope(scope);
+  if (typeof input !== "string") {
+    return resolveObjectEntryId(input, scope, context);
+  }
+  const raw = applyAlias(input, context.aliases);
+  const parsed = parseStringEntryId(raw);
+  if (parsed.namespace !== void 0 && parsed.namespace !== scope.namespace) {
+    throw new CliffScopeMismatchError(raw, scope, `${scope.namespace}.${scope.clan}.<group>.<id>`);
+  }
+  const exact = /* @__PURE__ */ new Map();
+  const mismatched = /* @__PURE__ */ new Map();
+  for (const candidate of candidateEntryIds(parsed, scope)) {
+    const record = context.recordForCanonical(candidate);
+    if (record === void 0) continue;
+    if (record.namespace !== scope.namespace || record.clan !== scope.clan) {
+      mismatched.set(record.canonical, record);
+    } else {
+      exact.set(record.canonical, record);
+    }
+  }
+  if (exact.size > 0) {
+    return partsOfRecord([...exact.values()][0]);
+  }
+  if (mismatched.size > 0) {
+    throw new CliffScopeMismatchError(raw, scope, `${scope.namespace}.${scope.clan}.<group>.<id>`);
+  }
+  const suffix = parsed.segments.join(".");
+  const suffixRecords = /* @__PURE__ */ new Map();
+  for (const canonical of context.suffixMatches(suffix)) {
+    const record = context.recordForCanonical(canonical);
+    if (record !== void 0) suffixRecords.set(record.canonical, record);
+  }
+  const inScope = [...suffixRecords.values()].filter(
+    (record) => record.namespace === scope.namespace && record.clan === scope.clan
+  );
+  if (inScope.length === 1) {
+    return partsOfRecord(inScope[0]);
+  }
+  if (inScope.length > 1) {
+    const candidates = inScope.map((record) => record.canonical).sort();
+    if (strictEntryIds) {
+      throw new CliffAmbiguousEntryError(raw, candidates);
+    }
+    const chosen = chooseByGroup(inScope, scope);
+    return {
+      ...partsOfRecord(chosen),
+      ambiguous: true,
+      candidates
+    };
+  }
+  if (suffixRecords.size > 0) {
+    throw new CliffScopeMismatchError(raw, scope, `${scope.namespace}.${scope.clan}.<group>.<id>`);
+  }
+  return parseAuthoringEntryId(parsed, scope, context);
+}
+
+// src/engine.ts
+function isCliffDocument(resource) {
+  return typeof resource === "object" && resource !== null && !(resource instanceof Uint8Array);
+}
+var I18nImpl = class {
+  catalog;
+  defaultParams;
+  missing;
+  requireEmotion;
+  enforceMaxWidth;
+  icu;
+  fallbacks;
+  strictEntryIds;
+  parseOptions;
+  onDiagnostic;
+  maxDiagnostics;
+  diagnosticsList = [];
+  listeners = /* @__PURE__ */ new Set();
+  currentLocale;
+  sourceLanguageValue;
+  version = 0;
+  constructor(options, defaultIcu) {
+    if (typeof options.locale !== "string" || options.locale.trim().length === 0) {
+      throw new CliffScopeError("locale is required");
+    }
+    this.currentLocale = options.locale.trim();
+    this.fallbacks = typeof options.fallbackLocale === "string" ? [options.fallbackLocale] : [...options.fallbackLocale ?? []];
+    const catalogOptions = {};
+    if (options.aliases !== void 0) catalogOptions.aliases = options.aliases;
+    if (options.defaultGroup !== void 0) catalogOptions.defaultGroup = options.defaultGroup;
+    this.catalog = new Catalog(catalogOptions);
+    this.defaultParams = options.params ?? {};
+    this.missing = options.missing ?? "entryId";
+    this.requireEmotion = options.requireEmotion ?? false;
+    this.enforceMaxWidth = options.enforceMaxWidth ?? "warn";
+    this.icu = options.icu ?? defaultIcu;
+    this.strictEntryIds = options.strictEntryIds ?? true;
+    this.parseOptions = options.parse ?? {};
+    this.onDiagnostic = options.onDiagnostic;
+    this.maxDiagnostics = options.maxDiagnostics ?? 1e3;
+    this.sourceLanguageValue = options.sourceLanguage;
+    for (const resource of options.resources ?? []) {
+      this.add(resource);
+    }
+    if (this.sourceLanguageValue === void 0 && this.catalog.sourceLanguages.length > 0) {
+      this.sourceLanguageValue = this.catalog.sourceLanguages[0];
+    }
+  }
+  get locale() {
+    return this.currentLocale;
+  }
+  get language() {
+    return this.currentLocale;
+  }
+  get sourceLanguage() {
+    return this.sourceLanguageValue;
+  }
+  getVersion() {
+    return this.version;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    this.version++;
+    for (const listener of this.listeners) listener();
+  }
+  setLocale(locale) {
+    const next = locale.trim();
+    if (next.length === 0) throw new CliffScopeError("locale must not be empty");
+    if (next === this.currentLocale) return;
+    this.currentLocale = next;
+    this.notify();
+  }
+  changeLanguage(locale) {
+    this.setLocale(locale);
+  }
+  scope(scope) {
+    assertScope(scope);
+    return { t: createT(this, scope), scope };
+  }
+  add(resource, options = {}) {
+    let document;
+    let issues;
+    let corrections = [];
+    if (isCliffDocument(resource)) {
+      document = resource;
+      issues = (0, import_core5.validateDocument)(document);
+    } else {
+      const parseOptions = {
+        ...this.parseOptions,
+        ...options.sourcePath === void 0 ? {} : { path: options.sourcePath }
+      };
+      if (options.tolerant === true) {
+        const result = (0, import_core5.parseTolerant)(resource, parseOptions);
+        document = result.document;
+        corrections = result.corrections;
+        issues = (0, import_core5.validateDocument)(document);
+      } else {
+        document = (0, import_core5.parse)(resource, parseOptions);
+        issues = (0, import_core5.validateDocument)(document);
+      }
+    }
+    if (options.validate !== false && (0, import_core5.hasErrors)(issues)) {
+      throw new import_core5.CliffValidationError(issues, corrections);
+    }
+    const added = this.catalog.addDocument(document);
+    if (this.sourceLanguageValue === void 0) {
+      this.sourceLanguageValue = document.header.sourceLanguage;
+    }
+    this.notify();
+    void added;
+    return { documents: [document], issues, corrections };
+  }
+  addDocument(document, options = {}) {
+    return this.add(document, options);
+  }
+  resolve(entryId, scope) {
+    const resolved = resolveEntryId(entryId, scope, this.catalog, this.strictEntryIds);
+    if (resolved.ambiguous === true) {
+      this.diagnose({
+        code: "ambiguous-entry",
+        severity: "warning",
+        message: `ambiguous entry "${typeof entryId === "string" ? entryId : entryId.id}"; chose "${resolved.canonical}"`,
+        entryId: resolved.canonical,
+        locale: this.currentLocale,
+        namespace: resolved.namespace,
+        clan: resolved.clan,
+        group: resolved.group,
+        ...resolved.candidates === void 0 ? {} : { details: { candidates: resolved.candidates } }
+      });
+    }
+    return resolved;
+  }
+  recordFor(canonical, locale) {
+    const chain = this.catalog.localeChain(locale, this.fallbacks, this.sourceLanguageValue);
+    return this.catalog.selectRecord(canonical, chain, this.sourceLanguageValue);
+  }
+  has(entryId, scope) {
+    const resolved = this.resolve(entryId, scope);
+    return resolved.exists && this.recordFor(resolved.canonical, this.currentLocale) !== void 0;
+  }
+  entryIds(scope = {}) {
+    return this.catalog.entryIds(scope);
+  }
+  query(options = {}) {
+    return this.catalog.query(options);
+  }
+  untranslated(options = {}) {
+    return this.catalog.untranslated(options);
+  }
+  byStatus(status, options = {}) {
+    return this.catalog.byStatus(status, options);
+  }
+  statusCounts(options = {}) {
+    return this.catalog.statusCounts(options);
+  }
+  namespaces() {
+    return this.catalog.namespaces();
+  }
+  clans(namespace) {
+    return this.catalog.clans(namespace);
+  }
+  groups(scope = {}) {
+    return this.catalog.groups(scope);
+  }
+  locales() {
+    return this.catalog.locales();
+  }
+  files(options = {}) {
+    return this.catalog.files(options);
+  }
+  toCliff(options = {}) {
+    return this.catalog.toCliff(options);
+  }
+  validate() {
+    return this.catalog.validate();
+  }
+  diagnostics() {
+    return this.diagnosticsList;
+  }
+  clearDiagnostics() {
+    this.diagnosticsList.length = 0;
+  }
+  diagnose(diagnostic) {
+    this.diagnosticsList.push(diagnostic);
+    if (this.diagnosticsList.length > this.maxDiagnostics) {
+      this.diagnosticsList.splice(0, this.diagnosticsList.length - this.maxDiagnostics);
+    }
+    if (this.onDiagnostic !== void 0) {
+      try {
+        this.onDiagnostic(diagnostic);
+      } catch {
+      }
+    }
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  getSourceLanguage() {
+    if (this.sourceLanguageValue === void 0) {
+      throw new CliffI18nError(
+        "CLIFF source-language is not set; pass sourceLanguage or load a CLIFF document"
+      );
+    }
+    return this.sourceLanguageValue;
+  }
+  getCatalog() {
+    return this.catalog;
+  }
+  format(message, params = {}, options = {}) {
+    const locale = options.locale ?? this.currentLocale;
+    const icuOptions = {};
+    if (options.currency !== void 0) icuOptions.currency = options.currency;
+    if (options.timeZone !== void 0) icuOptions.timeZone = options.timeZone;
+    try {
+      const result = this.icu.format(message, locale, params, icuOptions);
+      for (const error of result.errors) {
+        this.diagnose({
+          code: "icu-error",
+          severity: "warning",
+          message: `${error.type}: ${error.message}`,
+          locale,
+          ...error.source === void 0 ? {} : { details: { source: error.source } }
+        });
+      }
+      return result.text;
+    } catch (error) {
+      this.diagnose({
+        code: "icu-error",
+        severity: "error",
+        message: String(error),
+        locale
+      });
+      return message;
+    }
+  }
+  formatToParts(message, params = {}, options = {}) {
+    const locale = options.locale ?? this.currentLocale;
+    const icuOptions = {};
+    if (options.currency !== void 0) icuOptions.currency = options.currency;
+    if (options.timeZone !== void 0) icuOptions.timeZone = options.timeZone;
+    try {
+      const result = this.icu.formatToParts(message, locale, params, icuOptions);
+      for (const error of result.errors) {
+        this.diagnose({
+          code: "icu-error",
+          severity: "warning",
+          message: `${error.type}: ${error.message}`,
+          locale,
+          ...error.source === void 0 ? {} : { details: { source: error.source } }
+        });
+      }
+      return result.parts;
+    } catch (error) {
+      this.diagnose({
+        code: "icu-error",
+        severity: "error",
+        message: String(error),
+        locale
+      });
+      return [{ type: "literal", value: message }];
+    }
+  }
+};
+function createI18nEngine(options, defaultIcu) {
+  return new I18nImpl(options, defaultIcu);
+}
+
+// src/icu/detect.ts
+var MF2_DIRECTIVE_RE = /(^|[\s.])\.(input|local|match)\b/;
+var MF2_VARIABLE_RE = /\{\s*\$[A-Za-z_]/;
+var MF2_MARKUP_RE = /\{[#/][A-Za-z]/;
+var MF1_TYPE_RE = /\{\s*[A-Za-z_][A-Za-z0-9_-]*\s*,\s*(plural|select|selectordinal|number|date|time)\b/;
+function detectDialect(message) {
+  if (MF2_DIRECTIVE_RE.test(message) || MF2_VARIABLE_RE.test(message) || MF2_MARKUP_RE.test(message)) {
+    return "mf2";
+  }
+  if (MF1_TYPE_RE.test(message)) return "mf1";
+  if (message.includes("{{") || message.includes("}}")) return "mf2";
+  if (message.includes("{") || message.includes("}")) return "mf1";
+  return "plain";
+}
+function argumentNames(message, dialect) {
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (!seen.has(name)) {
+      seen.add(name);
+      names.push(name);
+    }
+  };
+  if (dialect === "mf2") {
+    for (const match of message.matchAll(/\{\s*\$([A-Za-z_][A-Za-z0-9_-]*)/g)) {
+      if (match[1] !== void 0) add(match[1]);
+    }
+    return names;
+  }
+  for (const match of message.matchAll(/\{\s*([A-Za-z_][A-Za-z0-9_-]*)\s*[,}]/g)) {
+    if (match[1] !== void 0) add(match[1]);
+  }
+  return names;
+}
+function analyzePlain(message, dialect, errors = []) {
+  return { dialect, arguments: argumentNames(message, dialect), errors };
+}
+
+// src/icu/lite.ts
+var SIMPLE_MESSAGE = /^[^{}]*(?:\{[A-Za-z_][A-Za-z0-9_]*\}[^{}]*)*$/;
+var SIMPLE_ARGUMENT = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function unsupported(message) {
+  return {
+    type: "icu-unsupported",
+    message: "the lite ICU runtime does not format plural/select/number/date messages; use @cliff-format/i18n instead",
+    source: message
+  };
+}
+function simpleParts(message, values) {
+  const parts = [];
+  let cursor = 0;
+  for (const match of message.matchAll(SIMPLE_ARGUMENT)) {
+    const index = match.index ?? 0;
+    if (index > cursor) parts.push({ type: "literal", value: message.slice(cursor, index) });
+    const name = match[1];
+    const value = values[name];
+    parts.push({
+      type: "expression",
+      source: `{${name}}`,
+      value: value === void 0 ? `{${name}}` : String(value)
+    });
+    cursor = index + match[0].length;
+  }
+  if (cursor < message.length) parts.push({ type: "literal", value: message.slice(cursor) });
+  if (parts.length === 0 && message.length > 0) parts.push({ type: "literal", value: message });
+  return parts;
+}
+function createLiteIcu() {
+  return {
+    format(message, _locale, values) {
+      const dialect = detectDialect(message);
+      if (dialect === "plain") return { text: message, errors: [] };
+      if (!SIMPLE_MESSAGE.test(message)) {
+        return { text: message, errors: [unsupported(message)] };
+      }
+      const errors = [];
+      const text = message.replace(SIMPLE_ARGUMENT, (whole, name) => {
+        const value = values[name];
+        if (value === void 0) {
+          errors.push({
+            type: "unresolved-var",
+            message: `missing ICU argument "${name}"`,
+            source: whole
+          });
+          return whole;
+        }
+        return String(value);
+      });
+      return { text, errors };
+    },
+    formatToParts(message, _locale, values) {
+      const dialect = detectDialect(message);
+      if (dialect === "plain") {
+        return { parts: [{ type: "literal", value: message }], errors: [] };
+      }
+      if (!SIMPLE_MESSAGE.test(message)) {
+        return {
+          parts: [{ type: "literal", value: message }],
+          errors: [unsupported(message)]
+        };
+      }
+      return { parts: simpleParts(message, values), errors: [] };
+    },
+    analyze(message) {
+      const dialect = detectDialect(message);
+      const errors = [];
+      if (dialect !== "plain" && !SIMPLE_MESSAGE.test(message)) {
+        errors.push(unsupported(message));
+      }
+      return analyzePlain(message, dialect, errors);
+    }
+  };
+}
+
+// src/create-lite.ts
+function createI18n(options) {
+  return createI18nEngine(options, options.icu ?? createLiteIcu());
+}
+//# sourceMappingURL=lite.cjs.map