@hawkeyexl/manni 4.8.0 → 4.9.0

package/dist/{chunk-HOE2C42K.js → chunk-YEUQ7OKT.js}

@@ -10,7 +10,7 @@ import {
   CONCEPT_FIELDS,
   fieldPointer,
   valueAt
-} from "./chunk-AZXCL5WH.js";
+} from "./chunk-IN6DWNVE.js";
 import {
   STDIN_LABEL,
   STDIN_TOKEN,
@@ -19,8 +19,9 @@ import {
   extractorForExtension,
   gitignoreOptions,
   locateFrontmatter,
-  resolveTargetSet
-} from "./chunk-A36QDIXZ.js";
+  resolveTargetSet,
+  supportedExtensions
+} from "./chunk-3XGGF5JW.js";
 import {
   findConfigFile,
   readConfigFile,
@@ -51,7 +52,21 @@ var TERM_FIELDS = [
   "narrower",
   "related-terms",
   "see",
-  "scope-note"
+  "scope-note",
+  "subject-field",
+  "contexts",
+  "notes",
+  "sources",
+  "customer-subsets",
+  "project-subsets",
+  "cross-references",
+  "external-cross-references",
+  "graphics",
+  "transactions",
+  "tbx-elements",
+  "concept-entry",
+  "designations",
+  "tbx-markup"
 ];
 var TERM_LIST_FIELDS = [
   "alt-labels",
@@ -60,6 +75,32 @@ var TERM_LIST_FIELDS = [
   "narrower",
   "related-terms"
 ];
+var TERM_AUX_FIELDS = [
+  "definition",
+  "subject-field",
+  "contexts",
+  "notes",
+  "sources",
+  "customer-subsets",
+  "project-subsets",
+  "cross-references",
+  "external-cross-references",
+  "graphics",
+  "transactions",
+  "tbx-elements"
+];
+var TERM_DESIGNATION_FIELDS = [
+  "administrative-status",
+  "part-of-speech",
+  "grammatical-gender",
+  "grammatical-number",
+  "term-type",
+  "term-location",
+  "geographical-usage",
+  "register",
+  "reading",
+  "reading-note"
+];
 var TERM_WRITE_FORMATS = [
   "markdown",
   "mdx",
@@ -69,6 +110,7 @@ var TERM_WRITE_FORMATS = [
   "dita",
   "docbook",
   "tbx",
+  "tbx3",
   "skos",
   "csv",
   "json",
@@ -244,6 +286,33 @@ async function resolveTermRun(opts) {
   };
 }
 
+// src/term/core/writers/render-util.ts
+var DEFAULT_LANGUAGE = "en";
+function languageOf(term) {
+  return term.language ?? DEFAULT_LANGUAGE;
+}
+function languageKey(term) {
+  return languageOf(term).toLowerCase();
+}
+function isMultilingual(terms) {
+  return new Set(terms.map(languageKey)).size > 1;
+}
+function droppedFields(terms, held) {
+  const dropped = [];
+  for (const term of terms) {
+    for (const field of TERM_FIELDS) {
+      if (term.record[field] !== void 0 && !held.includes(field)) dropped.push({ id: term.id, field });
+    }
+  }
+  return dropped;
+}
+function requireShape(format, target, shape) {
+  if (target.shape === shape) return;
+  throw new TermError(
+    shape === "file" ? `-f ${format} writes one file, not a directory. Pass -o <file>.` : `-f ${format} writes a styles directory, not a file. Pass -o <styles directory>.`
+  );
+}
+
 // src/term/commands/run.ts
 import { existsSync } from "node:fs";
 import { isAbsolute, relative, resolve as resolve3 } from "node:path";
@@ -417,39 +486,159 @@ function collapse(text) {
 function isListField(field) {
   return TERM_LIST_FIELDS.includes(field);
 }
-function recordOf(raw) {
+function isAuxField(field) {
+  return TERM_AUX_FIELDS.includes(field);
+}
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function itemsOf(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function pointerOf(path) {
+  return path.map((segment) => `/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+}
+function issueNotice(input, line, label, issue) {
+  return `${input.file}:${line}: ignored ${issue.what} on "${label}": ${issue.why}.`;
+}
+function oneValue(value, key, path, where, issues) {
+  const text = textOf(value);
+  if (text !== void 0 || value === void 0 || value === null || typeof value === "string") return text;
+  const article = /^[aeiou]/.test(key) ? "an" : "a";
+  const holds = Array.isArray(value) ? "holds one value, not a list" : typeof value === "object" ? "holds text, not a mapping" : "holds text";
+  issues?.push({ path, what: `${key}${where}`, why: `${article} ${key} ${holds}` });
+  return void 0;
+}
+function dateText(value) {
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) return textOf(value);
+  const iso = value.toISOString();
+  return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+}
+function mappedItems(value, key, path, where, issues, why, build) {
+  if (value === void 0 || value === null) return void 0;
+  const list = [];
+  itemsOf(value).forEach((item2, i) => {
+    const built = build(item2);
+    if (built !== void 0) list.push(built);
+    else if (item2 !== null && item2 !== void 0 && typeof item2 !== "string") {
+      issues?.push({ path: Array.isArray(value) ? [...path, i] : path, what: `${key} item${where}`, why });
+    }
+  });
+  return list.length === 0 ? void 0 : list;
+}
+function linkOf(item2) {
+  const bare = textOf(item2);
+  if (bare !== void 0) return { target: bare };
+  if (!isMapping2(item2)) return void 0;
+  const target = textOf(item2["target"]);
+  if (target === void 0) return void 0;
+  const text = textOf(item2["text"]);
+  return text === void 0 ? { target } : { target, text };
+}
+function transactionOf(item2) {
+  if (!isMapping2(item2)) return void 0;
+  const type = textOf(item2["type"]);
+  if (type === void 0) return void 0;
+  const transaction = { type };
+  const date = dateText(item2["date"]);
+  if (date !== void 0) transaction.date = date;
+  const responsibility = textOf(item2["responsibility"]);
+  if (responsibility !== void 0) transaction.responsibility = responsibility;
+  return transaction;
+}
+function setAux(target, field, value, path, where, issues) {
+  switch (field) {
+    case "definition":
+    case "subject-field": {
+      const text = oneValue(value, field, path, where, issues);
+      if (text !== void 0) target[field] = text;
+      return;
+    }
+    case "cross-references":
+    case "external-cross-references":
+    case "graphics": {
+      const why = `a ${field} item is text or a mapping with a target`;
+      const links = mappedItems(value, field, path, where, issues, why, linkOf);
+      if (links !== void 0) target[field] = links;
+      return;
+    }
+    case "transactions": {
+      const why = "a transactions item is a mapping with a type";
+      const transactions = mappedItems(value, field, path, where, issues, why, transactionOf);
+      if (transactions !== void 0) target[field] = transactions;
+      return;
+    }
+    default: {
+      const list = listOf(value);
+      if (list !== void 0) target[field] = list;
+    }
+  }
+}
+function conceptEntryOf(value, issues) {
+  if (value === void 0 || value === null) return void 0;
+  if (!isMapping2(value)) {
+    issues?.push({ path: ["concept-entry"], what: "concept-entry", why: "a concept-entry holds a mapping of fields" });
+    return void 0;
+  }
+  const entry = {};
+  for (const field of TERM_AUX_FIELDS) {
+    setAux(entry, field, value[field], ["concept-entry", field], " in concept-entry", issues);
+  }
+  return Object.keys(entry).length === 0 ? void 0 : entry;
+}
+function designationsOf(value, names, issues) {
+  if (value === void 0 || value === null) return void 0;
+  const list = [];
+  itemsOf(value).forEach((item2, i) => {
+    const path = Array.isArray(value) ? ["designations", i] : ["designations"];
+    const term = isMapping2(item2) ? textOf(item2["term"]) : void 0;
+    if (!isMapping2(item2) || term === void 0) {
+      issues?.push({ path, what: "designations item", why: "a designations item is a mapping with a term" });
+      return;
+    }
+    if (!names.includes(term)) {
+      issues?.push({ path, what: `designations item "${term}"`, why: "it names no label, alt-label or hidden-label" });
+      return;
+    }
+    const where = ` in designations item "${term}"`;
+    const designation = { term };
+    for (const key of TERM_DESIGNATION_FIELDS) {
+      const text = oneValue(item2[key], key, [...path, key], where, issues);
+      if (text !== void 0) designation[key] = text;
+    }
+    const comments = listOf(item2["transfer-comments"]);
+    if (comments !== void 0) designation["transfer-comments"] = comments;
+    for (const field of TERM_AUX_FIELDS) setAux(designation, field, item2[field], [...path, field], where, issues);
+    list.push(designation);
+  });
+  return list.length === 0 ? void 0 : list;
+}
+function recordOf(raw, issues) {
   const label = textOf(raw.label);
   if (label === void 0) return void 0;
   const record = { label };
   for (const field of TERM_FIELDS) {
-    if (isListField(field)) {
-      const list = listOf(raw[field]);
+    const value = raw[field];
+    if (field === "label") continue;
+    if (isListField(field) || field === "tbx-markup") {
+      const list = listOf(value);
       if (list !== void 0) record[field] = list;
-    } else if (field !== "label") {
-      const text = textOf(raw[field]);
+    } else if (isAuxField(field)) {
+      setAux(record, field, value, [field], "", issues);
+    } else if (field === "concept-entry") {
+      const entry = conceptEntryOf(value, issues);
+      if (entry !== void 0) record[field] = entry;
+    } else if (field === "designations") {
+      const names = [label, ...record["alt-labels"] ?? [], ...record["hidden-labels"] ?? []];
+      const designations = designationsOf(value, names, issues);
+      if (designations !== void 0) record[field] = designations;
+    } else {
+      const text = oneValue(value, field, [field], "", issues);
       if (text !== void 0) record[field] = text;
     }
   }
   return record;
 }
-function ignoredFields(raw) {
-  const ignored = [];
-  for (const field of TERM_FIELDS) {
-    if (field === "label" || isListField(field)) continue;
-    const value = raw[field];
-    if (value === void 0 || value === null || typeof value === "string") continue;
-    if (textOf(value) !== void 0) continue;
-    const given = Array.isArray(value) ? "list" : typeof value === "object" ? "mapping" : "other";
-    ignored.push({ field, given });
-  }
-  return ignored;
-}
-function ignoredNotice(input, line, label, ignored) {
-  const { field, given } = ignored;
-  const article = /^[aeiou]/.test(field) ? "an" : "a";
-  const holds = given === "list" ? "holds one value, not a list" : given === "mapping" ? "holds text, not a mapping" : "holds text";
-  return `${input.file}:${line}: ignored ${field} on "${label}": ${article} ${field} ${holds}.`;
-}
 function linesFor(record, lines) {
   const kept = {};
   for (const field of TERM_FIELDS) {
@@ -461,7 +650,7 @@ function linesFor(record, lines) {
 function idFor(record, recordId, constructId) {
   return textOf(recordId) ?? textOf(constructId) ?? slugOf(record.label);
 }
-function languageOf(input) {
+function languageOf2(input) {
   return textOf(input.metadata["language"]) ?? textOf(input.metadata["xml:lang"]);
 }
 function declares(input, type) {
@@ -472,7 +661,7 @@ function skipped(input, line, label) {
   return `${input.file}:${line}: skipped a ${label} entry with no term.`;
 }
 function termOf(input, parts) {
-  const language = languageOf(input);
+  const language = textOf(parts.language) ?? languageOf2(input);
   const location = {
     file: input.file,
     ...input.path === void 0 ? {} : { path: input.path },
@@ -547,7 +736,7 @@ function parseXml(input) {
   const shift = input.content.charCodeAt(0) === 65279 ? 1 : 0;
   const body = input.content.slice(shift);
   const errors = [];
-  let parsed = null;
+  let parsed2 = null;
   try {
     const doc = new DOMParser({
       onError: (level, message) => {
@@ -557,12 +746,12 @@ function parseXml(input) {
       }
     }).parseFromString(body, "text/xml");
     const root = doc.documentElement;
-    if (errors.length === 0 && root !== null) parsed = { root, body, shift, starts: lineStarts(body) };
+    if (errors.length === 0 && root !== null) parsed2 = { root, body, shift, starts: lineStarts(body) };
   } catch {
-    parsed = null;
+    parsed2 = null;
   }
-  cache.set(input, parsed);
-  return parsed;
+  cache.set(input, parsed2);
+  return parsed2;
 }
 function nameOf(el) {
   return (el.localName ?? el.nodeName).toLowerCase();
@@ -837,9 +1026,9 @@ function parseHtml(input) {
   const cached = cache2.get(input);
   if (cached !== void 0) return cached;
   const shift = input.content.charCodeAt(0) === 65279 ? 1 : 0;
-  const parsed = { root: parse(input.content.slice(shift), { sourceCodeLocationInfo: true }), shift };
-  cache2.set(input, parsed);
-  return parsed;
+  const parsed2 = { root: parse(input.content.slice(shift), { sourceCodeLocationInfo: true }), shift };
+  cache2.set(input, parsed2);
+  return parsed2;
 }
 function isElement(node) {
   return "tagName" in node;
@@ -875,11 +1064,11 @@ function attr(el, name) {
 function lineOf(el) {
   return el.sourceCodeLocation?.startLine ?? 1;
 }
-function spanOf(parsed, first, last) {
+function spanOf(parsed2, first, last) {
   const start = first.sourceCodeLocation?.startOffset;
   const end = last.sourceCodeLocation?.endOffset;
   if (start === void 0 || end === void 0) return void 0;
-  return { start: start + parsed.shift, end: end + parsed.shift };
+  return { start: start + parsed2.shift, end: end + parsed2.shift };
 }
 function definitionOf3(dd) {
   const paragraphs = childElements(dd).filter((child) => child.tagName === "p");
@@ -892,9 +1081,9 @@ function listItems(dl) {
 var DL_LABEL = "dl";
 function readDl(input) {
   if (!declares(input, "term-set")) return nothing();
-  const parsed = parseHtml(input);
+  const parsed2 = parseHtml(input);
   const result = nothing();
-  for (const dl of elementsNamed(parsed.root, "dl")) {
+  for (const dl of elementsNamed(parsed2.root, "dl")) {
     const items = listItems(dl).filter((item2) => item2.tagName === "dt" || item2.tagName === "dd");
     let i = 0;
     while (i < items.length) {
@@ -924,7 +1113,7 @@ function readDl(input) {
         result.notices.push(skipped(input, line, DL_LABEL));
         continue;
       }
-      const span = spanOf(parsed, first, last);
+      const span = spanOf(parsed2, first, last);
       const constructId = dts.map((dt) => textOf(attr(dt, "id"))).find((id) => id !== void 0);
       result.terms.push(
         termOf(input, {
@@ -964,9 +1153,9 @@ function dfnFields(dfn) {
 }
 function readDfn(input) {
   if (!declares(input, "term-set")) return nothing();
-  const parsed = parseHtml(input);
+  const parsed2 = parseHtml(input);
   const result = nothing();
-  for (const dfn of elementsNamed(parsed.root, "dfn")) {
+  for (const dfn of elementsNamed(parsed2.root, "dfn")) {
     if (insideDt(dfn)) continue;
     const { label, alt } = dfnFields(dfn);
     const line = lineOf(dfn);
@@ -975,7 +1164,7 @@ function readDfn(input) {
       result.notices.push(skipped(input, line, DFN_LABEL));
       continue;
     }
-    const span = spanOf(parsed, dfn, dfn);
+    const span = spanOf(parsed2, dfn, dfn);
     const term = termOf(input, {
       record,
       constructId: attr(dfn, "id"),
@@ -1009,6 +1198,10 @@ var FIELDS = new Set(TERM_FIELDS);
 function isField(key) {
   return FIELDS.has(key);
 }
+var ENTRY_KEYS = ["language", ...TERM_FIELDS];
+function isEntryKey(key) {
+  return key === "language" || isField(key);
+}
 function read2(input) {
   if ((input.path ?? input.file).toLowerCase().endsWith(".json")) {
     try {
@@ -1034,14 +1227,14 @@ function read2(input) {
   }
   const terms = [];
   const notices = [];
-  for (const pair of root.items) {
-    const keyNode = isScalar(pair.key) ? pair.key : void 0;
+  for (const pair2 of root.items) {
+    const keyNode = isScalar(pair2.key) ? pair2.key : void 0;
     const id = textOf(keyNode?.value);
     const line = lineOf2(keyNode) ?? 1;
     if (id === void 0) {
       throw new TermError(`${input.file}:${line}: an entry's key is its id, and must be a non-empty string.`);
     }
-    const value = pair.value;
+    const value = pair2.value;
     if (!isMap(value)) {
       throw new TermError(`${input.file}:${line}: entry "${id}" is not a mapping of fields.`);
     }
@@ -1055,34 +1248,45 @@ function read2(input) {
       raw[name] = isNode(fieldValue) ? fieldValue.toJSON() : fieldValue;
       lines[name] = lineOf2(fieldKey);
     }
-    const record = recordOf(raw);
+    const issues = [];
+    const record = recordOf(raw, issues);
     if (record === void 0) {
       notices.push(skipped(input, line, LABEL2));
       continue;
     }
-    for (const ignored of ignoredFields(raw)) {
-      notices.push(ignoredNotice(input, lines[ignored.field] ?? line, record.label, ignored));
+    for (const issue of issues) {
+      const nested = issue.path.length > 1 ? value.getIn(issue.path, true) : void 0;
+      const [top] = issue.path;
+      const topLine = typeof top === "string" && isField(top) ? lines[top] : void 0;
+      notices.push(issueNotice(input, (isNode(nested) ? lineOf2(nested) : void 0) ?? topLine ?? line, record.label, issue));
     }
-    terms.push(termOf(input, { record, recordId: id, construct: "manifest", line, lines }));
+    const language = value.get("language");
+    terms.push(termOf(input, { record, recordId: id, construct: "manifest", line, lines, language }));
   }
   return { terms, notices };
 }
-function entryOf(record) {
+function entryValues(language, record) {
+  return { ...record, ...language === void 0 ? {} : { language } };
+}
+function entryOf(term) {
+  const values = entryValues(term.language, term.record);
   const entry = {};
-  for (const field of TERM_FIELDS) {
-    const value = record[field];
-    if (value !== void 0) entry[field] = value;
+  for (const key of ENTRY_KEYS) {
+    const value = values[key];
+    if (value !== void 0) entry[key] = value;
   }
   return entry;
 }
-function currentRecord(value) {
+function currentValues(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  const entry = value;
   const raw = {};
-  for (const field of TERM_FIELDS) raw[field] = value[field];
-  return recordOf(raw) ?? {};
+  for (const field of TERM_FIELDS) raw[field] = entry[field];
+  return entryValues(textOf(entry["language"]), recordOf(raw) ?? {});
 }
-function changedFields(current, record) {
-  return TERM_FIELDS.filter((field) => JSON.stringify(current[field]) !== JSON.stringify(record[field]));
+function changedKeys(current, term) {
+  const next = entryValues(term.language, term.record);
+  return ENTRY_KEYS.filter((key) => JSON.stringify(current[key]) !== JSON.stringify(next[key]));
 }
 function applyJson(input, terms) {
   let data;
@@ -1102,20 +1306,21 @@ function applyJson(input, terms) {
       if (existing !== void 0) {
         throw new TermError(`${input.file}: entry "${term.id}" is not a mapping of fields.`);
       }
-      root[term.id] = entryOf(term.record);
+      root[term.id] = entryOf(term);
       changed = true;
       continue;
     }
     const entry = existing;
-    const fields = changedFields(currentRecord(entry), term.record);
-    if (fields.length === 0) continue;
+    const keys = changedKeys(currentValues(entry), term);
+    if (keys.length === 0) continue;
+    const values = entryValues(term.language, term.record);
     const next = {};
     for (const [key, value] of Object.entries(entry)) {
-      if (!isField(key) || !fields.includes(key)) next[key] = value;
-      else if (term.record[key] !== void 0) next[key] = term.record[key];
+      if (!isEntryKey(key) || !keys.includes(key)) next[key] = value;
+      else if (values[key] !== void 0) next[key] = values[key];
     }
-    for (const field of fields) {
-      if (term.record[field] !== void 0 && !(field in next)) next[field] = term.record[field];
+    for (const key of keys) {
+      if (values[key] !== void 0 && !(key in next)) next[key] = values[key];
     }
     root[term.id] = next;
     changed = true;
@@ -1127,31 +1332,34 @@ function applyJson(input, terms) {
 }
 function entryRanges(root) {
   const ranges = /* @__PURE__ */ new Map();
-  for (const pair of root.items) {
-    if (!isScalar(pair.key)) continue;
-    const id = textOf(pair.key.value);
-    const start = pair.key.range?.[0];
-    const end = isNode(pair.value) ? pair.value.range?.[1] : pair.key.range?.[1];
+  for (const pair2 of root.items) {
+    if (!isScalar(pair2.key)) continue;
+    const id = textOf(pair2.key.value);
+    const start = pair2.key.range?.[0];
+    const end = isNode(pair2.value) ? pair2.value.range?.[1] : pair2.key.range?.[1];
     if (id !== void 0 && start !== void 0 && end !== void 0) ranges.set(id, { start, end });
   }
   return ranges;
 }
-function editEntry(doc, entry, record) {
-  const fields = changedFields(currentRecord(entry.toJSON()), record);
-  for (const field of fields) {
-    const value = record[field];
+function editEntry(doc, entry, term) {
+  const keys = changedKeys(currentValues(entry.toJSON()), term);
+  const values = entryValues(term.language, term.record);
+  for (const key of keys) {
+    const value = values[key];
     if (value === void 0) {
-      entry.delete(field);
+      entry.delete(key);
     } else if (Array.isArray(value)) {
-      const previous = entry.get(field, true);
+      const previous = entry.get(key, true);
       const node = doc.createNode(value);
       node.flow = isSeq(previous) && previous.flow === true;
-      entry.set(field, node);
+      entry.set(key, node);
+    } else if (typeof value === "object" && value !== null) {
+      entry.set(key, doc.createNode(value));
     } else {
-      entry.set(field, value);
+      entry.set(key, value);
     }
   }
-  return fields.length > 0;
+  return keys.length > 0;
 }
 function applyYaml(input, terms) {
   const { content } = input;
@@ -1164,7 +1372,7 @@ function applyYaml(input, terms) {
   const root = doc.contents;
   if (root === null) {
     if (terms.length === 0) return content;
-    const entries = Object.fromEntries(terms.map((term) => [term.id, entryOf(term.record)]));
+    const entries = Object.fromEntries(terms.map((term) => [term.id, entryOf(term)]));
     return stringifyYaml(entries, { lineWidth: 0 }).replaceAll("\n", eol);
   }
   if (!isMap(root)) {
@@ -1175,16 +1383,16 @@ function applyYaml(input, terms) {
   const changed = [];
   const added = [];
   for (const term of terms) {
-    const pair = root.items.find((item2) => isScalar(item2.key) && textOf(item2.key.value) === term.id);
-    if (pair === void 0) {
-      root.add(doc.createPair(term.id, entryOf(term.record)));
+    const pair2 = root.items.find((item2) => isScalar(item2.key) && textOf(item2.key.value) === term.id);
+    if (pair2 === void 0) {
+      root.add(doc.createPair(term.id, entryOf(term)));
       added.push(term.id);
       continue;
     }
-    if (!isMap(pair.value)) {
+    if (!isMap(pair2.value)) {
       throw new TermError(`${input.file}: entry "${term.id}" is not a mapping of fields.`);
     }
-    if (editEntry(doc, pair.value, term.record)) changed.push(term.id);
+    if (editEntry(doc, pair2.value, term)) changed.push(term.id);
   }
   if (changed.length === 0 && added.length === 0) return content;
   const text = doc.toString({ lineWidth: 0 });
@@ -1229,13 +1437,12 @@ function read3(input) {
     raw[field] = input.metadata[field];
     lines[field] = input.lineFor(`/${field}`);
   }
-  const record = recordOf(raw);
+  const issues = [];
+  const record = recordOf(raw, issues);
   if (record === void 0) return { terms: [], notices: [skipped(input, 1, LABEL3)] };
   return {
     terms: [termOf(input, { record, recordId: input.metadata["id"], construct: "page", line: 1, lines })],
-    notices: ignoredFields(raw).map(
-      (ignored) => ignoredNotice(input, lines[ignored.field] ?? 1, record.label, ignored)
-    )
+    notices: issues.map((issue) => issueNotice(input, input.lineFor(pointerOf(issue.path)) ?? 1, record.label, issue))
   };
 }
 function apply(input, terms) {
@@ -1281,6 +1488,940 @@ var pageReader = {
   apply
 };
 
+// src/term/core/readers/tbx.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
+
+// src/term/core/writers/merge.ts
+import { isDeepStrictEqual } from "node:util";
+function conceptGroups(terms) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const term of terms) {
+    const group = groups.get(term.id);
+    if (group === void 0) groups.set(term.id, [term]);
+    else group.push(term);
+  }
+  return [...groups.values()];
+}
+function mergeFirst(id, values, prefix = "") {
+  const merged = {};
+  const conflicted = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value === void 0) continue;
+    for (const [key, field] of Object.entries(value)) {
+      if (field === void 0) continue;
+      if (!(key in merged)) merged[key] = field;
+      else if (!isDeepStrictEqual(merged[key], field)) conflicted.add(key);
+    }
+  }
+  return {
+    merged,
+    conflicts: Object.keys(merged).filter((key) => conflicted.has(key)).map((key) => ({ id, field: `${prefix}${key}` }))
+  };
+}
+
+// src/term/core/readers/tbx-model.ts
+import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
+var TBX_V3_NAMESPACE = "urn:iso:std:iso:30042:ed-2";
+var TBX_MODULE_NAMESPACES = {
+  min: "http://www.tbxinfo.net/ns/min",
+  basic: "http://www.tbxinfo.net/ns/basic",
+  lng: "http://www.tbxinfo.net/ns/linguist"
+};
+var sources = /* @__PURE__ */ new WeakMap();
+function rememberTbxSource(term, source) {
+  sources.set(term.location, source);
+}
+function tbxSourceOf(term) {
+  return sources.get(term.location);
+}
+function category(name, element, module) {
+  return { name, element, module };
+}
+var TBX_CATEGORIES = {
+  definition: category("definition", "descrip", "basic"),
+  subjectField: category("subjectField", "descrip", "min"),
+  context: category("context", "descrip", "basic"),
+  source: category("source", "admin", "basic"),
+  customerSubset: category("customerSubset", "admin", "min"),
+  projectSubset: category("projectSubset", "admin", "basic"),
+  crossReference: category("crossReference", "ref", "basic"),
+  externalCrossReference: category("externalCrossReference", "xref", "min"),
+  xGraphic: category("xGraphic", "xref", "basic"),
+  transactionType: category("transactionType", "transac", "basic"),
+  responsibility: category("responsibility", "transacNote", "basic"),
+  administrativeStatus: category("administrativeStatus", "termNote", "min"),
+  partOfSpeech: category("partOfSpeech", "termNote", "min"),
+  grammaticalGender: category("grammaticalGender", "termNote", "basic"),
+  grammaticalNumber: category("grammaticalNumber", "termNote", "lng"),
+  termType: category("termType", "termNote", "basic"),
+  termLocation: category("termLocation", "termNote", "basic"),
+  geographicalUsage: category("geographicalUsage", "termNote", "basic"),
+  register: category("register", "termNote", "lng"),
+  transferComment: category("transferComment", "termNote", "lng"),
+  reading: category("reading", "admin", "lng"),
+  readingNote: category("readingNote", "adminNote", "lng")
+};
+var TBX_TEXT_FIELDS = [
+  ["subject-field", "subjectField"],
+  ["contexts", "context"],
+  ["sources", "source"],
+  ["customer-subsets", "customerSubset"],
+  ["project-subsets", "projectSubset"]
+];
+var TBX_LINK_FIELDS = [
+  ["cross-references", "crossReference"],
+  ["external-cross-references", "externalCrossReference"],
+  ["graphics", "xGraphic"]
+];
+var TBX_TERM_NOTES = [
+  ["administrative-status", "administrativeStatus"],
+  ["part-of-speech", "partOfSpeech"],
+  ["grammatical-gender", "grammaticalGender"],
+  ["grammatical-number", "grammaticalNumber"],
+  ["term-type", "termType"],
+  ["term-location", "termLocation"],
+  ["geographical-usage", "geographicalUsage"],
+  ["register", "register"]
+];
+var TBX_STATUS_VALUES = {
+  preferred: "preferredTerm-admn-sts",
+  admitted: "admittedTerm-admn-sts",
+  deprecated: "deprecatedTerm-admn-sts",
+  superseded: "supersededTerm-admn-sts"
+};
+var TBX_NO_STATUS = "none";
+function lf(text) {
+  return text.replace(/\r\n?/g, "\n");
+}
+var markupTexts = /* @__PURE__ */ new Map();
+function markupText(markup) {
+  if (markupTexts.has(markup)) return markupTexts.get(markup);
+  let text;
+  try {
+    const errors = [];
+    const doc = new DOMParser2({
+      onError: (level, message) => {
+        if ((level === "error" || level === "fatalError") && !/entity not found/i.test(message)) errors.push(message);
+      }
+    }).parseFromString(`<x>${markup}</x>`, "text/xml");
+    const root = doc.documentElement;
+    text = errors.length > 0 || root === null ? void 0 : lf(root.textContent ?? "").trim();
+  } catch {
+    text = void 0;
+  }
+  markupTexts.set(markup, text);
+  return text;
+}
+function valueXml(value, markup) {
+  return markup.find((item2) => markupText(item2) === value) ?? xmlText(value);
+}
+function prefixOf(format, module) {
+  return format.prefixes?.[module] ?? module;
+}
+function categoryXml(name, value, ctx, target) {
+  const cat = TBX_CATEGORIES[name];
+  const dct = ctx.format.style === "dct";
+  const tag = dct ? `${prefixOf(ctx.format, cat.module)}:${cat.name}` : cat.element;
+  const attributes = `${dct ? "" : ` type="${cat.name}"`}${target === void 0 ? "" : ` target="${xmlAttribute(target)}"`}`;
+  if (value === "") return `<${tag}${attributes}/>`;
+  return `<${tag}${attributes}>${valueXml(value, ctx.markup)}</${tag}>`;
+}
+function plainXml(tag, value, ctx, attributes = "") {
+  return `<${tag}${attributes}>${valueXml(value, ctx.markup)}</${tag}>`;
+}
+function pair(wanted, pool, same) {
+  const used = /* @__PURE__ */ new Set();
+  const found = wanted.map((w) => {
+    const at = pool.findIndex((s, i) => !used.has(i) && same(w, s));
+    if (at === -1) return void 0;
+    used.add(at);
+    return pool[at];
+  });
+  const left = pool.filter((_, i) => !used.has(i));
+  return found.map((s) => s ?? left.shift());
+}
+function linkXml(name, link, ctx) {
+  return categoryXml(name, link.text ?? "", ctx, link.target);
+}
+function nest(lines) {
+  return lines.map((line) => `  ${line.replaceAll("\n", "\n  ")}`);
+}
+var TERM_NOTE_ITEM = new RegExp(
+  `^<(?:termNote(?:Grp)?|[\\w.-]+:(?:${Object.values(TBX_CATEGORIES).filter((cat) => cat.element === "termNote").map((cat) => cat.name).join("|")}))[\\s>/]`
+);
+function isTermNoteItem(item2) {
+  return TERM_NOTE_ITEM.test(item2);
+}
+function auxLines(aux, ctx, extra = []) {
+  const lines = [];
+  const grouped = aux.definition !== void 0 && (aux.sources !== void 0 || aux.notes !== void 0);
+  if (aux.definition !== void 0) {
+    const definition = categoryXml("definition", aux.definition, ctx);
+    if (grouped) {
+      lines.push(
+        "<descripGrp>",
+        ...nest([
+          definition,
+          ...(aux.sources ?? []).map((s) => categoryXml("source", s, ctx)),
+          ...(aux.notes ?? []).map((n) => plainXml("note", n, ctx))
+        ]),
+        "</descripGrp>"
+      );
+    } else {
+      lines.push(definition);
+    }
+  }
+  for (const [field, name] of TBX_TEXT_FIELDS) {
+    if (field === "sources" && grouped) continue;
+    const value = aux[field];
+    for (const item2 of typeof value === "string" ? [value] : value ?? []) lines.push(categoryXml(name, item2, ctx));
+  }
+  if (!grouped) for (const note of aux.notes ?? []) lines.push(plainXml("note", note, ctx));
+  for (const [field, name] of TBX_LINK_FIELDS) {
+    for (const link of aux[field] ?? []) lines.push(linkXml(name, link, ctx));
+  }
+  for (const transaction of aux.transactions ?? []) {
+    lines.push(
+      "<transacGrp>",
+      ...nest([
+        categoryXml("transactionType", transaction.type, ctx),
+        ...transaction.responsibility === void 0 ? [] : [categoryXml("responsibility", transaction.responsibility, ctx)],
+        ...transaction.date === void 0 ? [] : [plainXml("date", transaction.date, ctx)]
+      ]),
+      "</transacGrp>"
+    );
+  }
+  lines.push(...extra);
+  return lines;
+}
+function resolveDesignations(record) {
+  const pool = [
+    { term: record.label, status: "preferred", used: false },
+    ...(record["alt-labels"] ?? []).map((term) => ({ term, status: "admitted", used: false })),
+    ...(record["hidden-labels"] ?? []).map((term) => ({ term, status: "deprecated", used: false }))
+  ];
+  const out = [];
+  for (const designation of record.designations ?? []) {
+    const slot = pool.find((entry) => !entry.used && entry.term === designation.term);
+    if (slot !== void 0) slot.used = true;
+    out.push({ designation, status: designation["administrative-status"] ?? slot?.status ?? "admitted" });
+  }
+  for (const slot of pool) if (!slot.used) out.push({ designation: { term: slot.term }, status: slot.status });
+  return out;
+}
+function statusValue(status) {
+  if (status === TBX_NO_STATUS) return void 0;
+  return status in TBX_STATUS_VALUES ? TBX_STATUS_VALUES[status] : status;
+}
+function designationLines({ designation, status }, ctx, shape) {
+  const group = shape?.group;
+  const tag = group !== void 0 ? "ntig" : ctx.format.version === 3 ? "termSec" : "tig";
+  const notes = [];
+  for (const [field, name] of TBX_TERM_NOTES) {
+    const value = field === "administrative-status" ? statusValue(status) : designation[field];
+    if (value !== void 0) notes.push(categoryXml(name, value, ctx));
+  }
+  for (const comment of designation["transfer-comments"] ?? []) notes.push(categoryXml("transferComment", comment, ctx));
+  const items = designation["tbx-elements"] ?? [];
+  const reading = [];
+  if (designation.reading !== void 0) {
+    const admin = categoryXml("reading", designation.reading, ctx);
+    if (designation["reading-note"] === void 0) reading.push(admin);
+    else reading.push("<adminGrp>", ...nest([admin, categoryXml("readingNote", designation["reading-note"], ctx)]), "</adminGrp>");
+  }
+  const { "tbx-elements": _items, ...aux } = designation;
+  const head = [plainXml("term", designation.term, ctx, shape?.termAttributes), ...notes, ...items.filter(isTermNoteItem)];
+  const rest = auxLines(aux, ctx, [...reading, ...items.filter((item2) => !isTermNoteItem(item2))]);
+  const body = group === void 0 ? [...head, ...rest] : [`<termGrp${group}>`, ...nest(head), "</termGrp>", ...rest];
+  return [`<${tag}${shape?.attributes ?? ""}>`, ...nest(body), `</${tag}>`];
+}
+function languageLines(term, ctx, shape) {
+  const tag = ctx.format.version === 3 ? "langSec" : "langSet";
+  const { record } = term;
+  const aux = {};
+  for (const field of [
+    "definition",
+    "subject-field",
+    "contexts",
+    "notes",
+    "sources",
+    "customer-subsets",
+    "project-subsets",
+    "cross-references",
+    "external-cross-references",
+    "graphics",
+    "transactions"
+  ]) {
+    const value = record[field];
+    if (value !== void 0) Object.assign(aux, { [field]: value });
+  }
+  const designations = resolveDesignations(record);
+  const shapes = pair(designations, shape?.designations ?? [], (d, s) => d.designation.term === s.term);
+  return [
+    `<${tag} xml:lang="${xmlAttribute(term.language ?? DEFAULT_LANGUAGE)}"${shape?.attributes ?? ""}>`,
+    ...nest([
+      ...auxLines(aux, ctx, record["tbx-elements"] ?? []),
+      ...designations.flatMap((d, i) => designationLines(d, ctx, shapes[i]))
+    ]),
+    `</${tag}>`
+  ];
+}
+function tbxEntryLines(terms, format, shape) {
+  const [head] = terms;
+  if (head === void 0) return [];
+  const tag = format.version === 3 ? "conceptEntry" : "termEntry";
+  const concept = head.record["concept-entry"] ?? {};
+  const { "tbx-elements": conceptItems, ...conceptAux } = concept;
+  const languages = pair(
+    terms,
+    shape?.languages ?? [],
+    (t, s) => languageKey(t) === (s.language ?? DEFAULT_LANGUAGE).toLowerCase()
+  );
+  return [
+    `<${tag} id="${xmlAttribute(head.id)}"${shape?.attributes ?? ""}>`,
+    ...nest([
+      ...auxLines(conceptAux, { format, markup: head.record["tbx-markup"] ?? [] }, conceptItems ?? []),
+      ...terms.flatMap(
+        (term, i) => languageLines(term, { format, markup: term.record["tbx-markup"] ?? [] }, languages[i])
+      ),
+      ...shape?.unread ?? []
+    ]),
+    `</${tag}>`
+  ];
+}
+
+// src/term/core/readers/tbx.ts
+var LABEL4 = "TBX entry";
+var parsed = /* @__PURE__ */ new WeakMap();
+function parseTbx(input) {
+  const cached = parsed.get(input);
+  if (cached !== void 0) return cached;
+  const shift = input.content.charCodeAt(0) === 65279 ? 1 : 0;
+  const body = input.content.slice(shift);
+  const errors = [];
+  let root = null;
+  try {
+    root = new DOMParser3({
+      onError: (level, message) => {
+        if (level !== "error" && level !== "fatalError") return;
+        if (/entity not found/i.test(message)) return;
+        errors.push(message);
+      }
+    }).parseFromString(body, "text/xml").documentElement;
+  } catch (error) {
+    if (errors.length === 0) errors.push(error instanceof Error ? error.message : String(error));
+  }
+  const failure = errors[0] ?? (root === null ? "no root element" : void 0);
+  if (failure !== void 0 || root === null) {
+    throw new TermError(`${input.file}: could not be read as tbx: Invalid XML: ${failure ?? "no root element"}`);
+  }
+  const local = root.localName ?? root.nodeName;
+  if (local !== "martif" && local !== "tbx") {
+    throw new TermError(`${input.file}: is not TBX: its root element is <${root.nodeName}>, not <martif> or <tbx>.`);
+  }
+  const version = local === "martif" ? 2 : 3;
+  const prefixes = { min: "min", basic: "basic", lng: "lng" };
+  for (let i = 0; i < root.attributes.length; i++) {
+    const attribute = root.attributes.item(i);
+    if (attribute === null || !attribute.name.startsWith("xmlns:")) continue;
+    for (const module of Object.keys(TBX_MODULE_NAMESPACES)) {
+      if (TBX_MODULE_NAMESPACES[module] === attribute.value) prefixes[module] = attribute.name.slice("xmlns:".length);
+    }
+  }
+  const xml = { root, body, shift, starts: lineStarts(body) };
+  const doc = {
+    input,
+    xml,
+    ns: root.namespaceURI ?? "",
+    document: {
+      content: input.content,
+      version,
+      style: version === 3 && root.getAttribute("style") === "dct" ? "dct" : "dca",
+      prefixes
+    }
+  };
+  const bodyEl = structuralChildren(doc, root, "text").flatMap((text) => structuralChildren(doc, text, "body"))[0];
+  if (bodyEl !== void 0) {
+    const inner = innerSpan(doc, bodyEl);
+    if (inner !== void 0) doc.document.body = inner;
+  }
+  const headerEl = structuralChildren(doc, root, version === 3 ? "tbxHeader" : "martifHeader")[0];
+  const header = headerEl === void 0 ? void 0 : innerSpan(doc, headerEl);
+  if (header !== void 0) doc.document.header = header;
+  const backEl = structuralChildren(doc, root, "text").flatMap((text) => structuralChildren(doc, text, "back"))[0];
+  const back = backEl === void 0 ? void 0 : innerSpan(doc, backEl);
+  if (back !== void 0) doc.document.back = back;
+  parsed.set(input, doc);
+  return doc;
+}
+function isStructural(doc, el, local) {
+  return el.localName === local && (el.namespaceURI ?? "") === doc.ns;
+}
+function structuralChildren(doc, el, local) {
+  return childrenOf(el).filter((child) => isStructural(doc, child, local));
+}
+function onlyAttributes(el, allowed) {
+  for (let i = 0; i < el.attributes.length; i++) {
+    const name = el.attributes.item(i)?.name;
+    if (name === void 0 || name === "xmlns" || name.startsWith("xmlns:")) continue;
+    if (!allowed.includes(name)) return false;
+  }
+  return true;
+}
+function attributesOf(el, own = []) {
+  let out = "";
+  for (let i = 0; i < el.attributes.length; i++) {
+    const attribute = el.attributes.item(i);
+    if (attribute !== null && !own.includes(attribute.name)) out += ` ${attribute.name}="${xmlAttribute(attribute.value)}"`;
+  }
+  return out;
+}
+function categoryOf(doc, el) {
+  const dct = doc.document.style === "dct";
+  for (const cat of Object.values(TBX_CATEGORIES)) {
+    if (dct) {
+      if (el.localName === cat.name && el.namespaceURI === TBX_MODULE_NAMESPACES[cat.module]) return cat;
+    } else if (isStructural(doc, el, cat.element) && el.getAttribute("type") === cat.name) {
+      return cat;
+    }
+  }
+  return void 0;
+}
+function categoryAttributes(doc, cat) {
+  const linked = cat.element === "ref" || cat.element === "xref";
+  return [...doc.document.style === "dct" ? [] : ["type"], ...linked ? ["target"] : []];
+}
+function innerSpan(doc, el) {
+  const span = spanOfElement(doc.xml, el);
+  if (span === void 0) return void 0;
+  const open = tagEnd(doc.xml.body, span.start - doc.xml.shift);
+  if (open === void 0) return void 0;
+  const start = open.end + doc.xml.shift;
+  if (open.selfClosing) return { start, end: start };
+  return { start, end: doc.input.content.lastIndexOf("</", span.end - 1) };
+}
+var DTD_ENTITY = /&(?!(?:amp|lt|gt|quot|apos);|#)/;
+function valueOf(doc, el, allowMarkup = true, entities = false) {
+  const text = lf(el.textContent ?? "").trim();
+  if (text === "") return void 0;
+  const inner = innerSpan(doc, el);
+  const source = inner === void 0 ? void 0 : lf(doc.input.content.slice(inner.start, inner.end)).trim();
+  const entity = source !== void 0 && DTD_ENTITY.test(source);
+  if (entity && !entities) return void 0;
+  let marked = entity;
+  for (let i = 0; i < el.childNodes.length; i++) {
+    const type = el.childNodes.item(i)?.nodeType;
+    if (type === 1 || type === 7 || type === 8) marked = true;
+  }
+  if (!marked) return { text };
+  if (!allowMarkup || source === void 0) return void 0;
+  return markupText(source) === text ? { text, markup: source } : void 0;
+}
+function categoryValue(doc, el, name, allowMarkup = true) {
+  const cat = TBX_CATEGORIES[name];
+  if (categoryOf(doc, el) !== cat || !onlyAttributes(el, categoryAttributes(doc, cat))) return void 0;
+  return valueOf(doc, el, allowMarkup);
+}
+function plainValue(doc, el, local, allowMarkup = true) {
+  if (!isStructural(doc, el, local) || !onlyAttributes(el, [])) return void 0;
+  return valueOf(doc, el, allowMarkup);
+}
+function itemOf(doc, el) {
+  const { content } = doc.input;
+  const span = spanOfElement(doc.xml, el);
+  if (span === void 0) return `<${el.nodeName}/>`;
+  const indent = indentAt(content, span.start);
+  const lines = lf(content.slice(span.start, span.end)).split("\n");
+  const text = lines.map((line, i) => i > 0 && line.startsWith(indent) ? line.slice(indent.length) : line).join("\n");
+  const declarations = namespacesNeeded(doc, el).map(([prefix, uri]) => ` ${prefix === "" ? "xmlns" : `xmlns:${prefix}`}="${uri.replaceAll('"', "&quot;")}"`).join("");
+  const nameEnd = 1 + el.nodeName.length;
+  return `${text.slice(0, nameEnd)}${declarations}${text.slice(nameEnd)}`;
+}
+function namespacesNeeded(doc, el) {
+  const used = /* @__PURE__ */ new Set();
+  const declared = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node.prefix !== null && node.prefix !== "") used.add(node.prefix);
+    for (let i = 0; i < node.attributes.length; i++) {
+      const name = node.attributes.item(i)?.name ?? "";
+      if (name === "xmlns") declared.add("");
+      else if (name.startsWith("xmlns:")) declared.add(name.slice("xmlns:".length));
+      else if (name.includes(":")) used.add(name.slice(0, name.indexOf(":")));
+    }
+    for (const child of childrenOf(node)) walk(child);
+  };
+  walk(el);
+  if ((el.prefix ?? "") === "" && (el.namespaceURI ?? "") !== doc.ns && el.namespaceURI !== TBX_V3_NAMESPACE) {
+    used.add("");
+  }
+  const out = [];
+  for (const prefix of used) {
+    if (prefix === "xml" || declared.has(prefix)) continue;
+    const uri = el.lookupNamespaceURI(prefix === "" ? null : prefix);
+    if (uri !== null && uri !== "" && uri !== TBX_V3_NAMESPACE) out.push([prefix, uri]);
+  }
+  return out;
+}
+function push(aux, field, item2) {
+  const list = aux[field] ?? [];
+  list.push(item2);
+  Object.assign(aux, { [field]: list });
+}
+function definitionGroup(doc, el) {
+  if (!isStructural(doc, el, "descripGrp") || !onlyAttributes(el, [])) return void 0;
+  const [first, ...rest] = childrenOf(el);
+  if (first === void 0 || rest.length === 0) return void 0;
+  const definition = categoryValue(doc, first, "definition");
+  if (definition === void 0) return void 0;
+  const sources2 = [];
+  const notes = [];
+  for (const child of rest) {
+    const source = notes.length === 0 ? categoryValue(doc, child, "source") : void 0;
+    const note = source === void 0 ? plainValue(doc, child, "note") : void 0;
+    if (source !== void 0) sources2.push(source);
+    else if (note !== void 0) notes.push(note);
+    else return void 0;
+  }
+  return { definition, sources: sources2, notes };
+}
+function linkOf2(doc, el, name) {
+  const cat = TBX_CATEGORIES[name];
+  if (categoryOf(doc, el) !== cat || !onlyAttributes(el, categoryAttributes(doc, cat))) return void 0;
+  const target = el.getAttribute("target");
+  if (target === null || target === "" || target !== target.trim()) return void 0;
+  if (lf(el.textContent ?? "").trim() === "") return { link: { target } };
+  const value = valueOf(doc, el);
+  if (value === void 0) return void 0;
+  return { link: { target, text: value.text }, value };
+}
+function transactionOf2(doc, el) {
+  if (!isStructural(doc, el, "transacGrp") || !onlyAttributes(el, [])) return void 0;
+  const children = childrenOf(el);
+  const [first] = children;
+  const type = first === void 0 ? void 0 : categoryValue(doc, first, "transactionType", false);
+  if (type === void 0) return void 0;
+  const transaction = { type: type.text };
+  let i = 1;
+  const next = children[i];
+  const responsibility = next === void 0 ? void 0 : categoryValue(doc, next, "responsibility", false);
+  if (responsibility !== void 0) {
+    transaction.responsibility = responsibility.text;
+    i += 1;
+  }
+  const last = children[i];
+  const date = last === void 0 ? void 0 : plainValue(doc, last, "date", false);
+  if (date !== void 0) {
+    transaction.date = date.text;
+    i += 1;
+  }
+  return i === children.length ? transaction : void 0;
+}
+function readingGroup(doc, el) {
+  if (!isStructural(doc, el, "adminGrp") || !onlyAttributes(el, [])) return void 0;
+  const children = childrenOf(el);
+  const [first, second] = children;
+  if (children.length !== 2 || first === void 0 || second === void 0) return void 0;
+  const reading = categoryValue(doc, first, "reading", false);
+  const note = categoryValue(doc, second, "readingNote");
+  return reading === void 0 || note === void 0 ? void 0 : { reading, note };
+}
+function statusOf(text) {
+  for (const [status, value] of Object.entries(TBX_STATUS_VALUES)) if (value === text) return status;
+  return text in TBX_STATUS_VALUES || text === TBX_NO_STATUS ? void 0 : text;
+}
+function readLevel(doc, children, level, read8) {
+  let { aux } = read8;
+  const items = [];
+  const seen = [];
+  const keep = (value) => {
+    seen.push(value);
+    if (value.markup !== void 0) read8.markup.push(value.markup);
+    return value.text;
+  };
+  const definitionEl = children.find(
+    (child) => categoryValue(doc, child, "definition") !== void 0 || definitionGroup(doc, child) !== void 0
+  );
+  const mapped = (child) => {
+    const cat = categoryOf(doc, child);
+    const is = (name) => cat === TBX_CATEGORIES[name];
+    if (child === definitionEl) {
+      const group = definitionGroup(doc, child);
+      const plain = categoryValue(doc, child, "definition");
+      const definition = group?.definition ?? plain;
+      if (definition === void 0) return false;
+      aux.definition = keep(definition);
+      for (const source of group?.sources ?? []) push(aux, "sources", keep(source));
+      for (const note of group?.notes ?? []) push(aux, "notes", keep(note));
+      return true;
+    }
+    if (definitionEl !== void 0 && (is("source") || isStructural(doc, child, "note"))) return false;
+    if (isStructural(doc, child, "note")) {
+      const note = plainValue(doc, child, "note");
+      if (note === void 0) return false;
+      push(aux, "notes", keep(note));
+      return true;
+    }
+    if (isStructural(doc, child, "transacGrp")) {
+      const transaction = transactionOf2(doc, child);
+      if (transaction === void 0) return false;
+      for (const text of [transaction.type, transaction.responsibility, transaction.date]) if (text !== void 0) keep({ text });
+      push(aux, "transactions", transaction);
+      return true;
+    }
+    if (level === "term" && isStructural(doc, child, "adminGrp")) {
+      const group = readingGroup(doc, child);
+      if (group === void 0 || aux.reading !== void 0) return false;
+      aux.reading = keep(group.reading);
+      aux["reading-note"] = keep(group.note);
+      return true;
+    }
+    for (const [field, name] of TBX_TEXT_FIELDS) {
+      if (!is(name)) continue;
+      const value = categoryValue(doc, child, name);
+      if (value === void 0) return false;
+      if (field === "subject-field") {
+        if (aux["subject-field"] !== void 0) return false;
+        aux["subject-field"] = keep(value);
+      } else {
+        push(aux, field, keep(value));
+      }
+      return true;
+    }
+    for (const [field, name] of TBX_LINK_FIELDS) {
+      if (!is(name)) continue;
+      const link = linkOf2(doc, child, name);
+      if (link === void 0) return false;
+      if (link.value !== void 0) keep(link.value);
+      push(aux, field, link.link);
+      return true;
+    }
+    if (level !== "term") return false;
+    if (is("reading")) {
+      const reading = categoryValue(doc, child, "reading", false);
+      if (reading === void 0 || aux.reading !== void 0) return false;
+      aux.reading = keep(reading);
+      return true;
+    }
+    if (is("transferComment")) {
+      const comment = categoryValue(doc, child, "transferComment");
+      if (comment === void 0 || aux["transfer-comments"] !== void 0) return false;
+      aux["transfer-comments"] = [keep(comment)];
+      return true;
+    }
+    for (const [field, name] of TBX_TERM_NOTES) {
+      if (!is(name)) continue;
+      const value = categoryValue(doc, child, name, field !== "administrative-status");
+      if (value === void 0 || aux[field] !== void 0) return false;
+      if (field === "administrative-status") {
+        const status = statusOf(value.text);
+        if (status === void 0) return false;
+        keep(value);
+        aux[field] = status;
+      } else {
+        aux[field] = keep(value);
+      }
+      return true;
+    }
+    return false;
+  };
+  for (const child of children) {
+    const saved = read8.fits === void 0 ? void 0 : { aux: structuredClone(aux), markup: read8.markup.length };
+    seen.length = 0;
+    if (mapped(child) && (read8.fits === void 0 || seen.every(read8.fits))) continue;
+    if (saved !== void 0) {
+      aux = read8.aux = saved.aux;
+      read8.markup.length = saved.markup;
+    }
+    items.push(itemOf(doc, child));
+  }
+  const ordered = level === "term" ? [...items.filter(isTermNoteItem), ...items.filter((i) => !isTermNoteItem(i))] : items;
+  if (ordered.length > 0) aux["tbx-elements"] = ordered;
+}
+function readDesignation(doc, el, fits) {
+  let children = childrenOf(el);
+  let group;
+  if (isStructural(doc, el, "ntig")) {
+    [group] = structuralChildren(doc, el, "termGrp");
+    if (group === void 0) return void 0;
+    children = [...childrenOf(group), ...children.filter((child) => child !== group)];
+  }
+  const termEl = children.find((child) => isStructural(doc, child, "term"));
+  const term = termEl === void 0 ? void 0 : valueOf(doc, termEl, true, true);
+  const text = termEl === void 0 ? void 0 : textOf(lf(termEl.textContent ?? ""));
+  if (termEl === void 0 || text === void 0) return void 0;
+  const read8 = { aux: { term: text }, markup: term?.markup === void 0 ? [] : [term.markup], ...fits === void 0 ? {} : { fits } };
+  readLevel(
+    doc,
+    children.filter((child) => child !== termEl),
+    "term",
+    read8
+  );
+  const { "administrative-status": status, ...designation } = read8.aux;
+  const shape = {
+    term: text,
+    attributes: attributesOf(el),
+    termAttributes: attributesOf(termEl),
+    ...group === void 0 ? {} : { group: attributesOf(group) }
+  };
+  return {
+    designation,
+    term: term ?? { text },
+    markup: read8.markup,
+    status: status ?? TBX_NO_STATUS,
+    line: lineOfElement(termEl),
+    shape
+  };
+}
+function labelsOf2(read8) {
+  const preferred = read8.findIndex((d) => d.status === "preferred");
+  const labelAt = preferred === -1 ? 0 : preferred;
+  const alts = [];
+  const hiddens = [];
+  const order = [];
+  const altOrder = [];
+  const hiddenOrder = [];
+  const designations = read8.map((d, i) => {
+    const { status } = d;
+    let kind;
+    if (i === labelAt) kind = "label";
+    else if (status === "deprecated" || status === "superseded") kind = "deprecated";
+    else kind = "admitted";
+    if (kind === "admitted") {
+      alts.push(d.designation.term);
+      altOrder.push(i);
+    } else if (kind === "deprecated") {
+      hiddens.push(d.designation.term);
+      hiddenOrder.push(i);
+    }
+    const implied = kind === "label" ? "preferred" : kind;
+    return status === implied ? d.designation : { ...d.designation, "administrative-status": status };
+  });
+  order.push(labelAt, ...altOrder, ...hiddenOrder);
+  const reordered = order.some((at, i) => at !== i);
+  const detailed = designations.some((d) => Object.keys(d).length > 1);
+  return {
+    label: read8[labelAt]?.designation.term ?? "",
+    alts,
+    hiddens,
+    designations: reordered || detailed ? designations : void 0
+  };
+}
+function readParts(doc, entry, fits) {
+  const languageTag = doc.document.version === 3 ? "langSec" : "langSet";
+  const designationTags = doc.document.version === 3 ? ["termSec"] : ["tig", "ntig"];
+  const children = childrenOf(entry);
+  const concept = { aux: { term: "" }, markup: [], ...fits === void 0 ? {} : { fits: fits.concept } };
+  readLevel(
+    doc,
+    children.filter((child) => !isStructural(doc, child, languageTag)),
+    "concept",
+    concept
+  );
+  const languages = children.filter((child) => isStructural(doc, child, languageTag)).map((el, i) => {
+    const at = fits?.languages[i];
+    const designations = [];
+    const others = [];
+    for (const child of childrenOf(el)) {
+      const isDesignation = designationTags.some((tag) => isStructural(doc, child, tag));
+      const designation = isDesignation ? readDesignation(doc, child, at) : void 0;
+      if (designation !== void 0) designations.push(designation);
+      else others.push(child);
+    }
+    const language = { aux: { term: "" }, markup: [], ...at === void 0 ? {} : { fits: at } };
+    if (designations.length > 0) readLevel(doc, others, "language", language);
+    return { el, designations, language };
+  });
+  return { concept, languages };
+}
+function markupOf(concept, language) {
+  return [.../* @__PURE__ */ new Set([...concept.markup, ...language.language.markup, ...language.designations.flatMap((d) => d.markup)])];
+}
+function fitsOf(parts) {
+  const pools = parts.languages.map((language) => markupOf(parts.concept, language));
+  if (pools.every((pool) => pool.length === 0)) return void 0;
+  const fits = (pool, terms) => (value) => pool.find((item2) => markupText(item2) === value.text) === value.markup && terms.every((term) => term.text !== value.text || term.markup === value.markup);
+  return {
+    concept: fits(
+      [...new Set(pools.flat())],
+      parts.languages.flatMap((language) => language.designations.map((d) => d.term))
+    ),
+    languages: parts.languages.map((language, i) => fits(pools[i] ?? [], language.designations.map((d) => d.term)))
+  };
+}
+function readEntry2(doc, entry, result) {
+  const { input } = doc;
+  const first = readParts(doc, entry);
+  const fits = fitsOf(first);
+  const parts = fits === void 0 ? first : readParts(doc, entry, fits);
+  const { concept } = parts;
+  const { term: _none, ...conceptAux } = concept.aux;
+  const span = spanOfElement(doc.xml, entry);
+  const rootLanguage = doc.xml.root.getAttribute("xml:lang");
+  const read8 = [];
+  let entryId = textOf(entry.getAttribute("id"));
+  const shape = { attributes: attributesOf(entry, ["id"]), languages: [] };
+  for (const part of parts.languages) {
+    const { el: langEl, designations } = part;
+    if (designations.length === 0) {
+      result.notices.push(skipped(input, lineOfElement(langEl), "TBX"));
+      (shape.unread ??= []).push(itemOf(doc, langEl));
+      continue;
+    }
+    const { term: _term, ...languageAux } = part.language.aux;
+    const labels = labelsOf2(designations);
+    const markup = markupOf(concept, part);
+    const raw = {
+      ...languageAux,
+      label: labels.label,
+      "alt-labels": labels.alts,
+      "hidden-labels": labels.hiddens,
+      ...Object.keys(conceptAux).length === 0 ? {} : { "concept-entry": structuredClone(conceptAux) },
+      ...labels.designations === void 0 ? {} : { designations: labels.designations },
+      ...markup.length === 0 ? {} : { "tbx-markup": markup }
+    };
+    const record = recordOf(raw);
+    if (record === void 0) continue;
+    entryId ??= slugOf(record.label);
+    const term = termOf(input, {
+      record,
+      language: langEl.getAttribute("xml:lang") ?? rootLanguage,
+      constructId: entryId,
+      construct: "tbx-entry",
+      line: lineOfElement(langEl),
+      lines: { label: designations[0]?.line },
+      ...span === void 0 ? {} : { span }
+    });
+    if (span !== void 0) rememberTbxSource(term, { document: doc.document, span, shape });
+    shape.languages.push({
+      language: term.language,
+      attributes: attributesOf(langEl, ["xml:lang"]),
+      designations: designations.map((d) => d.shape)
+    });
+    read8.push(term);
+  }
+  result.terms.push(...read8);
+}
+function readTbx(input) {
+  const doc = parseTbx(input);
+  const result = nothing();
+  const body = doc.document.body;
+  if (body === void 0) return result;
+  const entryTag = doc.document.version === 3 ? "conceptEntry" : "termEntry";
+  for (const text of structuralChildren(doc, doc.xml.root, "text")) {
+    for (const bodyEl of structuralChildren(doc, text, "body")) {
+      for (const entry of structuralChildren(doc, bodyEl, entryTag)) readEntry2(doc, entry, result);
+    }
+  }
+  return result;
+}
+function sameTerm(a, b) {
+  return a.id === b.id && a.language === b.language && sameFields(a.record, b.record, TERM_FIELDS);
+}
+function applyTbx(input, terms, conflicts) {
+  const spliced = spliceEntries(input, terms, false);
+  conflicts?.push(...spliced.conflicts);
+  return spliced.content;
+}
+function exportTbxSource(document, file, terms) {
+  const input = { content: document.content, file, format: "tbx", metadata: {}, lineFor: () => void 0 };
+  return spliceEntries(input, terms, true);
+}
+function removeSpan(content, start, end) {
+  const lineStart = content.lastIndexOf("\n", start - 1) + 1;
+  const after = /^[ \t]*(\r?\n|$)/.exec(content.slice(end))?.[0];
+  if (!/^[ \t]*$/.test(content.slice(lineStart, start)) || after === void 0) {
+    return content.slice(0, start) + content.slice(end);
+  }
+  return content.slice(0, lineStart) + content.slice(end + after.length);
+}
+function spliceEntries(input, terms, exporting) {
+  const doc = parseTbx(input);
+  const { content } = input;
+  const groups = /* @__PURE__ */ new Map();
+  for (const term of readTbx(input).terms) {
+    const span = term.location.span;
+    if (span === void 0) continue;
+    const group = groups.get(span.start) ?? { end: span.end, current: [], next: [] };
+    group.current.push(term);
+    groups.set(span.start, group);
+  }
+  for (const term of terms) {
+    const span = term.location.span;
+    if (span === void 0) {
+      throw new TermError(
+        `${input.file}: term "${term.id}" cannot be written in place, because its entry has no position in the file.`
+      );
+    }
+    const group = groups.get(span.start);
+    if (group?.end !== span.end) {
+      throw new TermError(
+        `${input.file}: term "${term.id}" does not match an entry in the file. Read the file again before writing it.`
+      );
+    }
+    group.next.push(term);
+  }
+  const eol = lineEnding(content);
+  let next = content;
+  const conflicts = [];
+  for (const [start, group] of [...groups.entries()].sort((a, b) => b[0] - a[0])) {
+    if (group.next.length === 0) {
+      if (exporting) next = removeSpan(next, start, group.end);
+      continue;
+    }
+    const written = exporting || group.next.length >= group.current.length ? group.next : merge(group.current, group.next);
+    const unchanged = written.length === group.current.length && written.every((t, i) => {
+      const was = group.current[i];
+      return was !== void 0 && sameTerm(was, t);
+    });
+    if (unchanged) continue;
+    const shape = group.current[0] === void 0 ? void 0 : tbxSourceOf(group.current[0])?.shape;
+    const edited = withEditedConcept(written, group.current);
+    conflicts.push(...edited.conflicts);
+    const lines = tbxEntryLines(edited.terms, doc.document, shape);
+    const text = reindent(lines.join("\n"), indentAt(content, start), eol);
+    next = next.slice(0, start) + text + next.slice(group.end);
+  }
+  return { content: next, conflicts };
+}
+function withEditedConcept(written, current) {
+  const [head, ...rest] = written;
+  if (head === void 0) return { terms: written, conflicts: [] };
+  const read8 = current[0]?.record["concept-entry"] ?? {};
+  const concepts = written.map((t) => t.record["concept-entry"] ?? {});
+  const edits = (concept2) => TERM_AUX_FIELDS.filter((field) => !isDeepStrictEqual2(concept2[field], read8[field]));
+  const { conflicts } = mergeFirst(
+    head.id,
+    concepts.map((c) => Object.fromEntries(edits(c).map((field) => [field, { value: c[field] }]))),
+    "concept-entry."
+  );
+  const concept = {};
+  for (const field of TERM_AUX_FIELDS) {
+    copyField(concept, concepts.find((c) => edits(c).includes(field)) ?? read8, field);
+  }
+  const { "concept-entry": _old, ...record } = head.record;
+  const joined = Object.keys(concept).length === 0 ? record : { ...record, "concept-entry": concept };
+  return { terms: [{ ...head, record: joined }, ...rest], conflicts };
+}
+function copyField(to, from, field) {
+  const value = from[field];
+  if (value !== void 0) to[field] = value;
+}
+function merge(current, given) {
+  const left = [...given];
+  return current.map((term) => {
+    const at = left.findIndex((t) => languageKey(t) === languageKey(term));
+    return at === -1 ? term : left.splice(at, 1)[0] ?? term;
+  });
+}
+var tbxEntryReader = {
+  construct: "tbx-entry",
+  label: LABEL4,
+  formats: ["tbx"],
+  read: readTbx,
+  apply: applyTbx
+};
+
 // src/term/core/readers/structured.ts
 var STRUCTURED_READERS = [
   pageReader,
@@ -1289,7 +2430,8 @@ var STRUCTURED_READERS = [
   ditaGlossgroupReader,
   docbookGlossaryReader,
   htmlDlReader,
-  htmlDfnReader
+  htmlDfnReader,
+  tbxEntryReader
 ];
 
 // src/term/core/readers/body.ts
@@ -1370,7 +2512,7 @@ function skippedNotice(input, line, label, missing) {
 }
 
 // src/term/core/readers/asciidoc-glossary.ts
-var LABEL4 = "[glossary] list";
+var LABEL5 = "[glossary] list";
 var ATTRIBUTE = /^\[glossary\][ \t]*$/;
 var ITEM = /^[ \t]*(.*?[^:\s])::(?:[ \t]+(.*))?$/;
 var BLOCK_TITLE = /^\.[^.\s]/;
@@ -1419,13 +2561,13 @@ function readList(input, lines, at, terms, notices) {
           })
         );
       } else if (firstLabel !== void 0) {
-        notices.push(skippedNotice(input, firstLabel.line, LABEL4, "definition"));
+        notices.push(skippedNotice(input, firstLabel.line, LABEL5, "definition"));
       }
       open = void 0;
     }
     const [firstPending] = pending;
     if (firstPending !== void 0) {
-      notices.push(skippedNotice(input, firstPending.line, LABEL4, "definition"));
+      notices.push(skippedNotice(input, firstPending.line, LABEL5, "definition"));
       pending = [];
     }
   };
@@ -1477,14 +2619,14 @@ function itemTerm(line) {
 }
 var asciidocGlossaryReader = {
   construct: "asciidoc-glossary",
-  label: LABEL4,
+  label: LABEL5,
   formats: ["asciidoc"],
   read: read4,
   apply: (input, terms) => applyEntries(input, read4, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => asciidocEntry(term.record) })
 };
 
 // src/term/core/readers/markdown-deflist.ts
-var LABEL5 = "definition list";
+var LABEL6 = "definition list";
 var DEFINITION = /^:(?:[ \t]+(.*))?$/;
 var INDENTED = /^(?: {4}|\t)/;
 var HEADING = /^#{1,6}(?:[ \t]|$)/;
@@ -1521,7 +2663,7 @@ function read5(input) {
     }
     if (labels.length === 0 || labels.some((l) => HEADING.test(l.text))) {
       const orphan = lines[j];
-      if (orphan !== void 0) notices.push(skippedNotice(input, orphan.line, LABEL5, "term"));
+      if (orphan !== void 0) notices.push(skippedNotice(input, orphan.line, LABEL6, "term"));
       i = readDefinitions(lines, j, []);
       continue;
     }
@@ -1532,7 +2674,7 @@ function read5(input) {
     if (firstLabel === void 0 || kept === void 0) continue;
     const text = definitionText(kept.paragraphs);
     if (text === void 0) {
-      notices.push(skippedNotice(input, firstLabel.line, LABEL5, "definition"));
+      notices.push(skippedNotice(input, firstLabel.line, LABEL6, "definition"));
       continue;
     }
     for (const extra of definitions.slice(1)) {
@@ -1593,14 +2735,14 @@ function readDefinitions(lines, at, out) {
 }
 var markdownDeflistReader = {
   construct: "markdown-deflist",
-  label: LABEL5,
+  label: LABEL6,
   formats: ["markdown", "mdx"],
   read: read5,
   apply: (input, terms) => applyEntries(input, read5, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => markdownEntry(term.record) })
 };
 
 // src/term/core/readers/rst-glossary.ts
-var LABEL6 = ".. glossary::";
+var LABEL7 = ".. glossary::";
 var DIRECTIVE = /^[ \t]*\.\.[ \t]+glossary::[ \t]*$/;
 var CODE_DIRECTIVE = /^[ \t]*\.\.[ \t]+(?:code-block|code|sourcecode)::/;
 var EXPLICIT_MARKUP = /^[ \t]*\.\.(?:[ \t]|$)/;
@@ -1669,7 +2811,7 @@ function readGlossary(input, lines, at, terms, notices) {
           })
         );
       } else {
-        notices.push(skippedNotice(input, first.line, LABEL6, "definition"));
+        notices.push(skippedNotice(input, first.line, LABEL7, "definition"));
       }
     }
     labels = [];
@@ -1704,7 +2846,7 @@ function readGlossary(input, lines, at, terms, notices) {
     } else if (labels.length > 0) {
       definition = { line: line.line, paragraphs: [[line.text]], last: line, gap: false };
     } else if (!orphan) {
-      notices.push(skippedNotice(input, line.line, LABEL6, "term"));
+      notices.push(skippedNotice(input, line.line, LABEL7, "term"));
       orphan = true;
     }
   }
@@ -1718,7 +2860,7 @@ function termText(line) {
 }
 var rstGlossaryReader = {
   construct: "rst-glossary",
-  label: LABEL6,
+  label: LABEL7,
   formats: ["rst"],
   read: read6,
   apply: (input, terms) => applyEntries(input, read6, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => rstEntry(term.record) })
@@ -1743,10 +2885,18 @@ function readerForConstruct(construct, readers = TERM_READERS) {
 // src/term/core/load-set.ts
 var MANIFEST_FORMAT = "manifest";
 var MANIFEST_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
+var TBX_FORMAT = "tbx";
+var TBX_EXTENSION = ".tbx";
+function tbxInput(content, file, path) {
+  return { content, file, ...path === void 0 ? {} : { path }, format: TBX_FORMAT, metadata: {}, lineFor: () => void 0 };
+}
+function defaultExtensions() {
+  return [...supportedExtensions(), TBX_EXTENSION];
+}
 function manifestInput(content, file, path) {
   return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
 }
-function labelsOf2(value) {
+function labelsOf3(value) {
   if (typeof value === "string") return value.trim() === "" ? [] : [value];
   if (Array.isArray(value)) {
     return value.filter((item2) => typeof item2 === "string" && item2.trim() !== "");
@@ -1756,7 +2906,7 @@ function labelsOf2(value) {
 function referencesOf(input) {
   const references = [];
   const add = (value, pointer) => {
-    for (const label of labelsOf2(value)) {
+    for (const label of labelsOf3(value)) {
       const line = input.lineFor(pointer);
       references.push({ file: input.file, label, ...line === void 0 ? {} : { line } });
     }
@@ -1791,6 +2941,13 @@ function extractInput(content, file, path, format) {
     lineFor: extracted.lineFor
   };
 }
+async function readInput(path, file) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+  }
+}
 async function loadTermSet(opts) {
   const { run } = opts;
   const readers = opts.readers ?? TERM_READERS;
@@ -1812,7 +2969,7 @@ async function loadTermSet(opts) {
       inputs,
       cwd: run.base,
       exclude,
-      ...opts.exts === void 0 ? {} : { exts: opts.exts },
+      exts: opts.exts ?? defaultExtensions(),
       allowEmpty,
       ...gitignoreOptions({
         ...opts.noGitignore === true ? { flag: false } : {},
@@ -1834,32 +2991,24 @@ async function loadTermSet(opts) {
     for (const file of files) {
       const path = resolve2(run.base, file);
       if (namedFiles.has(file) && MANIFEST_EXTENSIONS.has(extname(file).toLowerCase())) {
-        let content2;
-        try {
-          content2 = await readFile(path, "utf8");
-        } catch (error) {
-          throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
-        }
-        read7(manifestInput(content2, file, path), readers, set);
+        read7(manifestInput(await readInput(path, file), file, path), readers, set);
+        continue;
+      }
+      if (extname(file).toLowerCase() === TBX_EXTENSION) {
+        read7(tbxInput(await readInput(path, file), file, path), readers, set);
         continue;
       }
       const extractor = extractorForExtension(extname(file));
       if (extractor === void 0) {
         throw new TermError(`${file}: no reader for its extension. Pass --as <format> through stdin to read it.`);
       }
-      let content;
-      try {
-        content = await readFile(path, "utf8");
-      } catch (error) {
-        throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
-      }
-      const input = extractInput(content, file, path, extractor.name);
+      const input = extractInput(await readInput(path, file), file, path, extractor.name);
       set.references.push(...referencesOf(input));
       read7(input, readers, set);
     }
   }
   if (usingStdin && opts.as !== void 0) {
-    const input = extractInput(opts.stdin ?? "", STDIN_LABEL, void 0, opts.as);
+    const input = opts.as.toLowerCase() === TBX_FORMAT ? tbxInput(opts.stdin ?? "", STDIN_LABEL) : extractInput(opts.stdin ?? "", STDIN_LABEL, void 0, opts.as);
     set.references.push(...referencesOf(input));
     read7(input, readers, set);
   }
@@ -1871,7 +3020,8 @@ async function loadTermSet(opts) {
       const source = run.configSource ?? "manni.config.yaml";
       throw new TermError(`${source}: term.manifests "${written}" does not exist.`);
     }
-    read7(manifestInput(content, path, path), readers, set);
+    const isTbx = extname(path).toLowerCase() === TBX_EXTENSION;
+    read7(isTbx ? tbxInput(content, path, path) : manifestInput(content, path, path), readers, set);
   }
   if (set.terms.length === 0 && !allowEmpty) {
     throw new TermError(
@@ -1942,11 +3092,19 @@ function plural(n, one, many = `${one}s`) {
 export {
   TermError,
   TERM_FIELDS,
+  TERM_AUX_FIELDS,
+  TERM_DESIGNATION_FIELDS,
   TERM_WRITE_FORMATS,
   TERM_RULES,
   DEFAULT_TERM_BASELINE_PATH,
   DEFAULT_ABSTRACT_MAX_LENGTH,
   resolveTermRun,
+  DEFAULT_LANGUAGE,
+  languageOf,
+  languageKey,
+  isMultilingual,
+  droppedFields,
+  requireShape,
   xmlText,
   xmlAttribute,
   sharedLanguage,
@@ -1961,9 +3119,17 @@ export {
   htmlDlEntry,
   ditaEntry,
   docbookEntry,
+  conceptGroups,
+  mergeFirst,
+  TBX_V3_NAMESPACE,
+  tbxSourceOf,
+  lf,
+  tbxEntryLines,
+  exportTbxSource,
   TERM_READERS,
   readerForConstruct,
   MANIFEST_FORMAT,
+  tbxInput,
   extractInput,
   loadTerms,
   loadSet,
@@ -1972,4 +3138,4 @@ export {
   valeConfigFor,
   plural
 };
-//# sourceMappingURL=chunk-HOE2C42K.js.map
+//# sourceMappingURL=chunk-YEUQ7OKT.js.map