@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/term-5ICGKPC3.js

@@ -0,0 +1,1592 @@
+#!/usr/bin/env node
+import {
+  renderFindingsJson,
+  renderFormatsJson,
+  renderGetJson,
+  renderListJson
+} from "./chunk-X3BPBDGQ.js";
+import {
+  renderFindingsPretty,
+  renderFormatsPretty,
+  renderGetPretty,
+  renderListPretty,
+  renderValeWiring,
+  renderWritePretty
+} from "./chunk-2U3ORT6D.js";
+import {
+  FINDING_FORMATS,
+  JUNIT_CLASSNAME,
+  RULE_ID_PREFIX,
+  foldValeSeverity,
+  isTermRule,
+  proseRuleId,
+  reportedFindings,
+  runCheck,
+  summarize,
+  toResults
+} from "./chunk-YYBFZLAJ.js";
+import {
+  LIST_FORMATS,
+  runList
+} from "./chunk-ERMSO34F.js";
+import {
+  renderFindingsGithub
+} from "./chunk-3AFUD75K.js";
+import {
+  DITA_HOLDS,
+  DOCBOOK_HOLDS,
+  LIST_HOLDS,
+  MANIFEST_FORMAT,
+  TERM_FIELDS,
+  TERM_READERS,
+  TERM_RULES,
+  TERM_WRITE_FORMATS,
+  TermError,
+  asciidocEntry,
+  displayPath,
+  ditaEntry,
+  docbookEntry,
+  extractInput,
+  fileOf,
+  formatChoice,
+  htmlDlEntry,
+  loadSet,
+  loadTerms,
+  markdownEntry,
+  plural,
+  readerForConstruct,
+  reindent,
+  resolveTermRun,
+  rstEntry,
+  sharedLanguage,
+  valeConfigFor,
+  xmlAttribute,
+  xmlText
+} from "./chunk-WQE54PNH.js";
+import "./chunk-77AINBYM.js";
+import "./chunk-IKEWBMCN.js";
+import "./chunk-TU2WUBVZ.js";
+import "./chunk-H2DLH2JI.js";
+import {
+  registerTermLabelSource
+} from "./chunk-CYWHFSRT.js";
+import "./chunk-K3D6FPV6.js";
+import {
+  collect,
+  readStdin,
+  splitList
+} from "./chunk-V46OILVC.js";
+import "./chunk-RLR4TKUZ.js";
+import {
+  OMITTED_WHEN_CLEAN,
+  renderJunit,
+  renderSarif
+} from "./chunk-C6OH6CNF.js";
+import {
+  STDIN_TOKEN,
+  extractorByName,
+  extractorForExtension
+} from "./chunk-JVTNMVYU.js";
+import {
+  fail
+} from "./chunk-YEUYKR62.js";
+import {
+  shouldColor
+} from "./chunk-RNVYGWIC.js";
+import "./chunk-MNH7QO4Z.js";
+import {
+  notice
+} from "./chunk-Q35YIDBV.js";
+import {
+  package_default
+} from "./chunk-UZC7LDAQ.js";
+import "./chunk-OWBRDNRZ.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/term/cli.ts
+import { Command } from "commander";
+
+// src/term/core/writers/documents.ts
+import { join } from "node:path";
+
+// src/term/core/writers/page.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function pageMetadata(term) {
+  const { record } = term;
+  const metadata = { title: record.label };
+  if (record.abstract !== void 0) metadata["description"] = record.abstract;
+  metadata["type"] = "term";
+  metadata["id"] = term.id;
+  if (term.language !== void 0) metadata["language"] = term.language;
+  for (const field of TERM_FIELDS) {
+    const value = record[field];
+    if (value !== void 0) metadata[field] = value;
+  }
+  return metadata;
+}
+function metadataPage(format, term) {
+  const apply = extractorByName(format)?.apply;
+  if (apply === void 0) throw new TermError(`manni cannot write ${format} metadata.`);
+  return apply("---\n---\n", pageMetadata(term));
+}
+function yamlFrontmatter(metadata) {
+  return `---
+${stringifyYaml(metadata, { lineWidth: 0 })}---
+`;
+}
+function metaContent(value) {
+  if (typeof value === "string" && !value.includes("\n")) {
+    try {
+      if (parseYaml(value) === value) return value;
+    } catch {
+    }
+  }
+  return JSON.stringify(value);
+}
+function htmlPage(term) {
+  const metadata = pageMetadata(term);
+  const metas = Object.entries(metadata).filter(([key]) => key !== "title").map(([key, value]) => `    <meta name="${xmlAttribute(key)}" content="${xmlAttribute(metaContent(value))}">`);
+  return fileOf([
+    "<!DOCTYPE html>",
+    "<html>",
+    "  <head>",
+    `    <title>${xmlText(term.record.label)}</title>`,
+    ...metas,
+    "  </head>",
+    "  <body></body>",
+    "</html>"
+  ]);
+}
+
+// src/term/core/writers/render-util.ts
+var DEFAULT_LANGUAGE = "en";
+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/core/writers/documents.ts
+var UNSAFE_NAME = /[/\\:*?"<>|]/;
+function pagePaths(terms, target, extension) {
+  const seen = /* @__PURE__ */ new Set();
+  return terms.map((term) => {
+    if (UNSAFE_NAME.test(term.id) || term.id === "." || term.id === "..") {
+      throw new TermError(`the id "${term.id}" cannot name a file. Give the term an id without path characters.`);
+    }
+    if (seen.has(term.id)) {
+      throw new TermError(`two terms have the id "${term.id}", and a directory holds one file per id.`);
+    }
+    seen.add(term.id);
+    return join(target.path, `${term.id}${extension}`);
+  });
+}
+function documentWriter(spec) {
+  const { directory } = spec;
+  return {
+    format: spec.format,
+    shapes: directory === void 0 ? ["file"] : ["file", "directory"],
+    holds: (shape) => shape === "directory" && directory !== void 0 ? directory.holds : spec.file.holds,
+    render(terms, target) {
+      if (target.shape === "directory" && directory !== void 0) {
+        const paths = pagePaths(terms, target, spec.extension);
+        return {
+          files: terms.map((term, i) => ({ path: paths[i] ?? "", content: directory.render(term) })),
+          removals: [],
+          dropped: droppedFields(terms, directory.holds),
+          skipped: []
+        };
+      }
+      requireShape(spec.format, target, "file");
+      const written = spec.file.needsDefinition ? terms.filter((t) => t.record.definition !== void 0) : terms;
+      return {
+        files: [{ path: target.path, content: spec.file.render(written) }],
+        removals: [],
+        dropped: droppedFields(written, spec.file.holds),
+        skipped: terms.filter((t) => !written.includes(t)).map((t) => t.id)
+      };
+    }
+  };
+}
+function entriesBlock(entries, indent = "") {
+  return entries.flatMap((entry, i) => [
+    ...i === 0 ? [] : [""],
+    `${indent}${reindent(entry, indent, "\n")}`
+  ]);
+}
+function markupBlock(entries, indent) {
+  return entries.map((entry) => `${indent}${reindent(entry, indent, "\n")}`);
+}
+function textPage(format) {
+  return (term) => metadataPage(format, term);
+}
+function listFrontmatter(terms, type) {
+  const metadata = {};
+  if (type) metadata["type"] = "term-set";
+  const language = sharedLanguage(terms);
+  if (language !== void 0) metadata["language"] = language;
+  if (Object.keys(metadata).length === 0) return [];
+  return [yamlFrontmatter(metadata).replace(/\n$/, ""), ""];
+}
+function markdownList(terms) {
+  return fileOf([...listFrontmatter(terms, true), ...entriesBlock(terms.map((t) => markdownEntry(t.record)))]);
+}
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>';
+function langAttribute(language) {
+  return language === void 0 ? "" : ` xml:lang="${xmlAttribute(language)}"`;
+}
+var markdownWriter = documentWriter({
+  format: "markdown",
+  extension: ".md",
+  file: { holds: LIST_HOLDS, render: markdownList, needsDefinition: true },
+  directory: { holds: TERM_FIELDS, render: textPage("markdown") }
+});
+var mdxWriter = documentWriter({
+  format: "mdx",
+  extension: ".mdx",
+  file: { holds: LIST_HOLDS, render: markdownList, needsDefinition: true },
+  directory: { holds: TERM_FIELDS, render: textPage("mdx") }
+});
+var asciidocWriter = documentWriter({
+  format: "asciidoc",
+  extension: ".adoc",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => fileOf([...listFrontmatter(terms, false), "[glossary]", ...entriesBlock(terms.map((t) => asciidocEntry(t.record)))])
+  },
+  directory: { holds: TERM_FIELDS, render: textPage("asciidoc") }
+});
+var rstWriter = documentWriter({
+  format: "rst",
+  extension: ".rst",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => fileOf([
+      ...listFrontmatter(terms, false),
+      ".. glossary::",
+      "",
+      ...entriesBlock(
+        terms.map((t) => rstEntry(t.record)),
+        "   "
+      )
+    ])
+  },
+  directory: { holds: TERM_FIELDS, render: textPage("rst") }
+});
+var htmlWriter = documentWriter({
+  format: "html",
+  extension: ".html",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => {
+      const language = sharedLanguage(terms);
+      return fileOf([
+        "<!DOCTYPE html>",
+        "<html>",
+        "  <head>",
+        "    <title>Glossary</title>",
+        '    <meta name="type" content="term-set">',
+        ...language === void 0 ? [] : [`    <meta name="language" content="${xmlAttribute(language)}">`],
+        "  </head>",
+        "  <body>",
+        "    <dl>",
+        ...markupBlock(terms.map(htmlDlEntry), "      "),
+        "    </dl>",
+        "  </body>",
+        "</html>"
+      ]);
+    }
+  },
+  directory: { holds: TERM_FIELDS, render: htmlPage }
+});
+var ditaWriter = documentWriter({
+  format: "dita",
+  extension: ".dita",
+  file: {
+    holds: DITA_HOLDS,
+    needsDefinition: false,
+    render: (terms) => fileOf([
+      XML_DECLARATION,
+      '<!DOCTYPE glossgroup PUBLIC "-//OASIS//DTD DITA 2.0 Glossary Group//EN" "glossgroup.dtd">',
+      `<glossgroup id="glossary"${langAttribute(sharedLanguage(terms))}>`,
+      "  <title>Glossary</title>",
+      ...markupBlock(terms.map((t) => ditaEntry(t)), "  "),
+      "</glossgroup>"
+    ])
+  },
+  directory: {
+    holds: DITA_HOLDS,
+    render: (term) => fileOf([
+      XML_DECLARATION,
+      '<!DOCTYPE glossentry PUBLIC "-//OASIS//DTD DITA 2.0 Glossary Entry//EN" "glossentry.dtd">',
+      ditaEntry(term, term.language)
+    ])
+  }
+});
+var docbookWriter = documentWriter({
+  format: "docbook",
+  extension: ".xml",
+  file: {
+    holds: DOCBOOK_HOLDS,
+    needsDefinition: false,
+    render: (terms) => fileOf([
+      XML_DECLARATION,
+      `<glossary xmlns="http://docbook.org/ns/docbook" version="5.0"${langAttribute(sharedLanguage(terms))}>`,
+      "  <title>Glossary</title>",
+      ...markupBlock(terms.map(docbookEntry), "  "),
+      "</glossary>"
+    ])
+  }
+});
+var DOCUMENT_WRITERS = [
+  markdownWriter,
+  mdxWriter,
+  asciidocWriter,
+  rstWriter,
+  htmlWriter,
+  ditaWriter,
+  docbookWriter
+];
+
+// src/term/core/writers/csv.ts
+var LANGUAGE_COLUMNS = [
+  ["label", "Term"],
+  ["definition", "Definition"],
+  ["abstract", "Abstract"],
+  ["alt-labels", "Alt labels"],
+  ["hidden-labels", "Hidden labels"],
+  ["scope-note", "Scope note"]
+];
+var NEUTRAL_COLUMNS = [
+  ["broader", "Broader"],
+  ["narrower", "Narrower"],
+  ["related-terms", "Related terms"],
+  ["see", "See"]
+];
+var LIST_SEPARATOR = " | ";
+function cell(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+function fieldText(term, field) {
+  const value = term.record[field];
+  if (value === void 0) return "";
+  return typeof value === "string" ? value : value.join(LIST_SEPARATOR);
+}
+var csvWriter = {
+  format: "csv",
+  shapes: ["file"],
+  holds: (_shape) => TERM_FIELDS,
+  render(terms, target) {
+    requireShape("csv", target, "file");
+    const languages = [];
+    for (const term of terms) {
+      const language = term.language ?? DEFAULT_LANGUAGE;
+      if (!languages.includes(language)) languages.push(language);
+    }
+    const header = [
+      "ID",
+      ...languages.flatMap((language) => LANGUAGE_COLUMNS.map(([, name]) => `${name} [${language}]`)),
+      ...NEUTRAL_COLUMNS.map(([, name]) => name)
+    ];
+    const rows = terms.map((term) => {
+      const own = term.language ?? DEFAULT_LANGUAGE;
+      return [
+        term.id,
+        ...languages.flatMap(
+          (language) => LANGUAGE_COLUMNS.map(([field]) => language === own ? fieldText(term, field) : "")
+        ),
+        ...NEUTRAL_COLUMNS.map(([field]) => fieldText(term, field))
+      ];
+    });
+    const content = [header, ...rows].map((row) => `${row.map(cell).join(",")}
+`).join("");
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, TERM_FIELDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/json.ts
+var jsonWriter = {
+  format: "json",
+  shapes: ["file"],
+  holds: (_shape) => TERM_FIELDS,
+  render(terms, target) {
+    requireShape("json", target, "file");
+    const entries = terms.map((term) => {
+      const entry = { id: term.id };
+      if (term.language !== void 0) entry["language"] = term.language;
+      for (const field of TERM_FIELDS) {
+        const value = term.record[field];
+        if (value !== void 0) entry[field] = value;
+      }
+      return entry;
+    });
+    const content = `${JSON.stringify({ terms: entries }, null, 2)}
+`;
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, TERM_FIELDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/skos.ts
+var HOLDS = [
+  "label",
+  "definition",
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms",
+  "scope-note"
+];
+var CONTEXT = {
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  dcterms: "http://purl.org/dc/terms/"
+};
+var SCHEME_ID = "";
+function literal(term, value) {
+  return term.language === void 0 ? value : { "@value": value, "@language": term.language };
+}
+function resolve(terms, self, value) {
+  const wanted = value.toLowerCase();
+  const others = terms.filter((t) => t !== self);
+  return others.find((t) => t.record.label.toLowerCase() === wanted) ?? others.find((t) => t.id.toLowerCase() === wanted);
+}
+function references(terms, self, values) {
+  const ids = [];
+  for (const value of values ?? []) {
+    const target = resolve(terms, self, value);
+    if (target !== void 0 && !ids.includes(target.id)) ids.push(target.id);
+  }
+  return ids.map((id) => ({ "@id": `#${id}` }));
+}
+function concept(terms, term) {
+  const { record } = term;
+  const node = {
+    "@id": `#${term.id}`,
+    "@type": "skos:Concept",
+    "skos:inScheme": { "@id": SCHEME_ID },
+    "skos:prefLabel": literal(term, record.label)
+  };
+  if (record["alt-labels"] !== void 0) node["skos:altLabel"] = record["alt-labels"].map((v) => literal(term, v));
+  if (record["hidden-labels"] !== void 0) {
+    node["skos:hiddenLabel"] = record["hidden-labels"].map((v) => literal(term, v));
+  }
+  if (record.definition !== void 0) node["skos:definition"] = literal(term, record.definition);
+  if (record["scope-note"] !== void 0) node["skos:scopeNote"] = literal(term, record["scope-note"]);
+  const relations = [
+    ["skos:broader", record.broader],
+    ["skos:narrower", record.narrower],
+    ["skos:related", record["related-terms"]]
+  ];
+  for (const [key, values] of relations) {
+    const refs = references(terms, term, values);
+    if (refs.length > 0) node[key] = refs;
+  }
+  return node;
+}
+var skosWriter = {
+  format: "skos",
+  shapes: ["file"],
+  holds: (_shape) => HOLDS,
+  render(terms, target) {
+    requireShape("skos", target, "file");
+    const document = {
+      "@context": CONTEXT,
+      "@graph": [
+        {
+          "@id": SCHEME_ID,
+          "@type": "skos:ConceptScheme",
+          "dcterms:description": "Generated by manni term write."
+        },
+        ...terms.map((term) => concept(terms, term))
+      ]
+    };
+    const content = `${JSON.stringify(document, null, 2)}
+`;
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, HOLDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/tbx.ts
+var HOLDS2 = ["label", "definition", "alt-labels", "hidden-labels"];
+function text(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function attribute(value) {
+  return text(value).replaceAll('"', "&quot;");
+}
+function tig(designation, status) {
+  return [
+    "          <tig>",
+    `            <term>${text(designation)}</term>`,
+    `            <termNote type="administrativeStatus">${status}</termNote>`,
+    "          </tig>"
+  ];
+}
+function termEntry(term) {
+  const { record } = term;
+  return [
+    `      <termEntry id="${attribute(term.id)}">`,
+    ...record.definition === void 0 ? [] : [`        <descrip type="definition">${text(record.definition)}</descrip>`],
+    `        <langSet xml:lang="${attribute(term.language ?? DEFAULT_LANGUAGE)}">`,
+    ...tig(record.label, "preferredTerm-admn-sts"),
+    ...(record["alt-labels"] ?? []).flatMap((label) => tig(label, "admittedTerm-admn-sts")),
+    ...(record["hidden-labels"] ?? []).flatMap((label) => tig(label, "deprecatedTerm-admn-sts")),
+    "        </langSet>",
+    "      </termEntry>"
+  ];
+}
+var tbxWriter = {
+  format: "tbx",
+  shapes: ["file"],
+  holds: (_shape) => HOLDS2,
+  render(terms, target) {
+    requireShape("tbx", target, "file");
+    const language = terms[0]?.language ?? DEFAULT_LANGUAGE;
+    const lines = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      `<martif type="TBX" xml:lang="${attribute(language)}">`,
+      "  <martifHeader>",
+      "    <fileDesc>",
+      "      <sourceDesc>",
+      "        <p>manni term write</p>",
+      "      </sourceDesc>",
+      "    </fileDesc>",
+      "  </martifHeader>",
+      "  <text>",
+      "    <body>",
+      ...terms.flatMap(termEntry),
+      "    </body>",
+      "  </text>",
+      "</martif>"
+    ];
+    const content = lines.map((line) => `${line}
+`).join("");
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, HOLDS2),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/vale.ts
+import { isAbsolute, join as join2, relative, sep } from "node:path";
+import { stringify } from "yaml";
+var VALE_MARKER = "# Generated by manni term write. Edit the terms, not this file.";
+var STYLE = "Terms";
+var HOLDS3 = ["label", "alt-labels", "hidden-labels"];
+var OWN_FILES = ["Casing", "Lowercase", "SentenceStart", "Deprecated"];
+var REGEX_METACHARACTERS = /[\\^$.|?*+()[\]{}]/g;
+function escapeRegex(value) {
+  return value.replace(REGEX_METACHARACTERS, "\\$&");
+}
+function swapValue(value) {
+  return value.search(REGEX_METACHARACTERS) === -1 ? value : escapeRegex(value);
+}
+function scalar(value) {
+  if (/[\r\n]/.test(value)) return JSON.stringify(value);
+  const out = stringify(value, { version: "1.1", lineWidth: 0 });
+  return out.endsWith("\n") ? out.slice(0, -1) : out;
+}
+function doubleQuoted(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("\r", "\\r");
+  return `"${escaped}"`;
+}
+function singleQuoted(value) {
+  return `'${value.replaceAll("'", "''").replaceAll(/[\r\n]+/g, " ")}'`;
+}
+function messageText(value) {
+  return value.replaceAll("%", "%%");
+}
+function casingOf(value) {
+  if (!/[\p{Lu}\p{Ll}\p{Lt}]/u.test(value)) return "none";
+  const letters = value.match(new RegExp("\\p{L}", "gu"))?.length ?? 0;
+  if (letters >= 2 && !/[\p{Ll}\p{Lt}]/u.test(value)) return "all-caps";
+  if (!/[\p{Lu}\p{Lt}]/u.test(value)) return "lowercase";
+  if (new RegExp("^\\p{Ll}", "u").test(value)) return "lowercase-initial";
+  return "mixed";
+}
+function sentenceStartPattern(value) {
+  const [first = "", ...rest] = Array.from(value);
+  const upper = first.toUpperCase();
+  const head = upper !== first && Array.from(upper).length === 1 ? `[${upper}${first}]` : escapeRegex(first);
+  return `${head}${escapeRegex(rest.join(""))}`;
+}
+var Swaps = class {
+  entries = /* @__PURE__ */ new Map();
+  add(key, value) {
+    if (!this.entries.has(key)) this.entries.set(key, value);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  lines() {
+    return [...this.entries].map(([key, value]) => `  ${scalar(key)}: ${scalar(value)}`);
+  }
+};
+var ASCII_WORD = /^[A-Za-z0-9_]$/;
+function bounded(pattern, text2) {
+  const chars = Array.from(text2);
+  const edge = (char) => char !== void 0 && ASCII_WORD.test(char) ? "\\b" : "\\B";
+  return `${edge(chars[0])}${pattern}${edge(chars.at(-1))}`;
+}
+function substitution(message, level, options, swaps) {
+  return [
+    VALE_MARKER,
+    "extends: substitution",
+    `message: ${doubleQuoted(message)}`,
+    `level: ${level}`,
+    "ignorecase: true",
+    "nonword: true",
+    ...options,
+    "swap:",
+    ...swaps.lines()
+  ].map((line) => `${line}
+`).join("");
+}
+function acronymRule(acronym, label) {
+  const expansion = escapeRegex(label).replaceAll(/[\r\n]+/g, " ");
+  return [
+    VALE_MARKER,
+    "extends: conditional",
+    `message: ${doubleQuoted(messageText(`Spell out '${acronym}' on first use, as '${label} (${acronym})'.`))}`,
+    "level: warning",
+    "ignorecase: false",
+    `first: ${singleQuoted(`\\b(${escapeRegex(acronym)})\\b`)}`,
+    `second: ${singleQuoted(`(?i)${expansion} \\((${escapeRegex(acronym)})\\)`)}`
+  ].map((line) => `${line}
+`).join("");
+}
+function acronymFileName(acronym) {
+  return acronym.replaceAll(/[^\p{L}\p{N}_-]/gu, "-");
+}
+function firstLine(content) {
+  const end = content.search(/\r?\n/);
+  return end === -1 ? content : content.slice(0, end);
+}
+var valeWriter = {
+  format: "vale",
+  shapes: ["directory"],
+  holds: (_shape) => HOLDS3,
+  render(terms, target, context) {
+    requireShape("vale", target, "directory");
+    const termsDir = join2(target.path, STYLE);
+    const marked = [];
+    for (const [path, content] of context.existing) {
+      const rel = relative(termsDir, path);
+      if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
+      if (firstLine(content) !== VALE_MARKER) {
+        throw new TermError(`${path} was not written by manni. Move it, or pass -o <styles directory>.`);
+      }
+      if (!rel.includes(sep) && !rel.includes("/")) marked.push(path);
+    }
+    const casing = new Swaps();
+    const lowercase = new Swaps();
+    const sentenceStart = new Swaps();
+    const deprecated = new Swaps();
+    const acronyms = [];
+    const labels = new Set(terms.map((t) => t.record.label));
+    for (const term of terms) {
+      const { label } = term.record;
+      const labelIsAllCaps = casingOf(label) === "all-caps";
+      for (const designation of [label, ...term.record["alt-labels"] ?? []]) {
+        const kind = casingOf(designation);
+        if (kind === "lowercase") lowercase.add(bounded(escapeRegex(designation), designation), sentenceStartPattern(designation));
+        if (kind === "lowercase-initial") {
+          sentenceStart.add(bounded(escapeRegex(designation.toLowerCase()), designation), sentenceStartPattern(designation));
+        }
+        if (kind === "mixed") casing.add(bounded(escapeRegex(designation.toLowerCase()), designation), swapValue(designation));
+        if (kind !== "all-caps" || designation === label || labelIsAllCaps || labels.has(designation)) continue;
+        const name = acronymFileName(designation);
+        const own = OWN_FILES.find((file) => file.toLowerCase() === name.toLowerCase());
+        if (own !== void 0) {
+          throw new TermError(`the acronym "${designation}" would replace Terms/${own}.yml. Rename the alt-label.`);
+        }
+        const taken = acronyms.find((a) => a.name.toLowerCase() === name.toLowerCase());
+        if (taken?.acronym === designation) continue;
+        if (taken !== void 0) {
+          throw new TermError(
+            `the acronyms "${taken.acronym}" and "${designation}" would both write Terms/${taken.name}.yml. Rename one.`
+          );
+        }
+        acronyms.push({ acronym: designation, name, content: acronymRule(designation, label) });
+      }
+      for (const hidden of term.record["hidden-labels"] ?? []) {
+        deprecated.add(bounded(escapeRegex(hidden), hidden), swapValue(label));
+      }
+    }
+    const files = [];
+    const add = (name, content) => {
+      files.push({ path: join2(termsDir, `${name}.yml`), content });
+    };
+    if (casing.size > 0) {
+      add("Casing", substitution("Use '%s' instead of '%s'.", "error", ["vocab: false"], casing));
+    }
+    if (lowercase.size > 0) {
+      add(
+        "Lowercase",
+        substitution("Write '%[2]s' in lowercase, except to start a sentence.", "error", ["vocab: false"], lowercase)
+      );
+    }
+    if (sentenceStart.size > 0) {
+      add(
+        "SentenceStart",
+        substitution(
+          "Write '%[2]s' as the term list spells it, with a capital only to start a sentence.",
+          "error",
+          ["vocab: false"],
+          sentenceStart
+        )
+      );
+    }
+    if (deprecated.size > 0) {
+      add("Deprecated", substitution("Use '%s' instead of '%s'.", "warning", ["matchcase: true"], deprecated));
+    }
+    for (const acronym of acronyms) add(acronym.name, acronym.content);
+    const produced = new Set(files.map((f) => relative(termsDir, f.path).toLowerCase()));
+    const removals = marked.filter((path) => !produced.has(relative(termsDir, path).toLowerCase())).sort();
+    return { files, removals, dropped: droppedFields(terms, HOLDS3), skipped: [] };
+  }
+};
+
+// src/term/core/writers/interchange.ts
+var INTERCHANGE_WRITERS = [tbxWriter, skosWriter, csvWriter, jsonWriter, valeWriter];
+
+// src/term/core/writers/index.ts
+var TERM_WRITERS = [...DOCUMENT_WRITERS, ...INTERCHANGE_WRITERS];
+
+// src/term/commands/formats.ts
+var FORMATS_FORMATS = ["pretty", "json"];
+var DOCUMENT_RENDERS = {
+  markdown: { input: "markdown", shapes: { directory: "page", file: "markdown-deflist" } },
+  mdx: { input: "mdx", shapes: { directory: "page", file: "markdown-deflist" } },
+  asciidoc: { input: "asciidoc", shapes: { directory: "page", file: "asciidoc-glossary" } },
+  rst: { input: "rst", shapes: { directory: "page", file: "rst-glossary" } },
+  html: { input: "html", shapes: { directory: "page", file: "html-dl" } },
+  dita: { input: "xml", shapes: { directory: "dita-glossentry", file: "dita-glossgroup" } },
+  docbook: { input: "xml", shapes: { file: "docbook-glossary" } }
+};
+var INTERCHANGE_LABELS = {
+  tbx: "TBX v2 Core",
+  skos: "JSON-LD",
+  vale: "style"
+};
+function rendered(writers, format, construct) {
+  return writers.some((writer) => {
+    const render = DOCUMENT_RENDERS[writer.format];
+    if (render?.input !== format) return false;
+    return writer.shapes.some((shape) => render.shapes[shape] === construct);
+  });
+}
+function listFormats(opts = {}) {
+  const readers = opts.readers ?? TERM_READERS;
+  const writers = opts.writers ?? TERM_WRITERS;
+  const formats = [];
+  for (const reader of readers) {
+    for (const format of reader.formats) if (!formats.includes(format)) formats.push(format);
+  }
+  const rows = [];
+  for (const format of formats) {
+    for (const reader of readers.filter((r) => r.formats.includes(format))) {
+      rows.push({
+        format,
+        construct: reader.construct,
+        label: reader.label,
+        read: true,
+        write: reader.apply !== void 0 || rendered(writers, format, reader.construct)
+      });
+    }
+  }
+  for (const writer of writers) {
+    if (DOCUMENT_RENDERS[writer.format] !== void 0) continue;
+    rows.push({ format: writer.format, label: INTERCHANGE_LABELS[writer.format] ?? "", read: false, write: true });
+  }
+  return rows;
+}
+
+// src/term/commands/get.ts
+var GET_FORMATS = ["pretty", "json"];
+function findTerm(terms, query) {
+  const folded = query.toLowerCase();
+  return terms.find((t) => t.id === query) ?? terms.find((t) => t.record.label.toLowerCase() === folded) ?? terms.find((t) => (t.record["alt-labels"] ?? []).some((alt) => alt.toLowerCase() === folded));
+}
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row.push(Math.min((row[j - 1] ?? 0) + 1, (prev[j] ?? 0) + 1, (prev[j - 1] ?? 0) + cost));
+    }
+    prev = row;
+  }
+  return prev[b.length] ?? 0;
+}
+function closestName(query, names) {
+  const limit = Math.max(2, Math.floor(query.length / 3));
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const name of names) {
+    const distance = editDistance(query, name);
+    if (distance < bestDistance) {
+      best = name;
+      bestDistance = distance;
+    }
+  }
+  return bestDistance <= limit ? best : void 0;
+}
+async function runGet(opts) {
+  const { set } = await loadTerms(opts);
+  const found = findTerm(set.terms, opts.term);
+  if (found !== void 0) return found;
+  const nearest = closestName(
+    opts.term,
+    set.terms.flatMap((t) => [t.id, t.record.label])
+  );
+  const hint = nearest === void 0 ? "." : `; did you mean "${nearest}"?`;
+  throw new TermError(`no term "${opts.term}". ${plural(set.terms.length, "term")}${hint}`);
+}
+
+// src/term/core/lint.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/term/core/vale.ts
+import { execFile } from "node:child_process";
+var MAX_BUFFER = 64 * 1024 * 1024;
+var SEVERITIES = ["error", "warning", "suggestion"];
+var spawnVale = (args, opts) => new Promise((settle, reject) => {
+  execFile(
+    "vale",
+    args,
+    { cwd: opts.cwd, windowsHide: true, maxBuffer: MAX_BUFFER, encoding: "utf8" },
+    (error, stdout, stderr) => {
+      if (!error) {
+        settle({ code: 0, stdout, stderr });
+        return;
+      }
+      if (typeof error.code === "number") {
+        settle({ code: error.code, stdout, stderr });
+        return;
+      }
+      if (error.code == null && typeof error.signal === "string") {
+        settle({ code: null, signal: error.signal, stdout, stderr });
+        return;
+      }
+      const failure = error;
+      reject(failure);
+    }
+  );
+});
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+async function start(spawn, args, cwd, missing) {
+  try {
+    return await spawn(args, { cwd });
+  } catch (err) {
+    if (isEnoent(err)) throw new TermError(missing);
+    throw err;
+  }
+}
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function failureText(result) {
+  const stderr = result.stderr.trim();
+  try {
+    const parsed = JSON.parse(stderr);
+    if (isMapping(parsed) && typeof parsed["Text"] === "string") return parsed["Text"].trim();
+  } catch {
+  }
+  if (stderr !== "") return stderr;
+  if (result.signal != null) return `killed by ${result.signal}`;
+  return `exit code ${String(result.code)}`;
+}
+function parseJson(stdout, what) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    throw new TermError(`vale printed ${what} that is not JSON: ${stdout.trim().slice(0, 200)}`);
+  }
+}
+function parseAlert(raw, path) {
+  const unreadable = () => new TermError(`vale printed an alert for ${path} that manni cannot read: ${JSON.stringify(raw)}`);
+  if (!isMapping(raw)) throw unreadable();
+  const { Check, Message, Line, Span, Severity } = raw;
+  if (typeof Check !== "string" || typeof Message !== "string" || typeof Line !== "number") throw unreadable();
+  if (!Array.isArray(Span) || Span.length !== 2) throw unreadable();
+  const span = Span;
+  const [from, to] = span;
+  if (typeof from !== "number" || typeof to !== "number") throw unreadable();
+  const severity = SEVERITIES.find((s) => s === Severity);
+  if (severity === void 0) throw unreadable();
+  return { Check, Message, Line, Span: [from, to], Severity: severity };
+}
+function parseAlerts(stdout) {
+  const parsed = parseJson(stdout, "alerts");
+  if (!isMapping(parsed)) throw new TermError("vale printed alerts that are not a JSON object.");
+  const alerts = {};
+  for (const [path, list] of Object.entries(parsed)) {
+    if (!Array.isArray(list)) throw new TermError(`vale printed alerts for ${path} that are not a list.`);
+    alerts[path] = list.map((raw) => parseAlert(raw, path));
+  }
+  return alerts;
+}
+async function runValeJson(files, opts, spawn = spawnVale) {
+  const args = ["--output=JSON", ...opts.config === void 0 ? [] : ["--config", opts.config], ...files];
+  const result = await start(spawn, args, opts.cwd, "vale is not on PATH. Install Vale to lint definitions.");
+  if (result.code !== 0 && result.code !== 1) {
+    throw new TermError(`vale could not lint definitions: ${failureText(result)}`);
+  }
+  return parseAlerts(result.stdout);
+}
+var NO_CONFIG = /no config file found|\.vale\.ini not found/i;
+function stringList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const list = [];
+  for (const item of value) {
+    if (typeof item !== "string") return void 0;
+    list.push(item);
+  }
+  return list;
+}
+async function valeLsConfig(opts, spawn = spawnVale) {
+  const args = [...opts.config === void 0 ? [] : ["--config", opts.config], "ls-config"];
+  const result = await start(
+    spawn,
+    args,
+    opts.cwd,
+    "vale is not on PATH. Install Vale, or pass -o <styles directory>."
+  );
+  if (result.code !== 0) {
+    const text2 = failureText(result);
+    if (NO_CONFIG.test(text2)) return null;
+    throw new TermError(`vale could not resolve its configuration: ${text2}`);
+  }
+  const parsed = parseJson(result.stdout, "a configuration");
+  if (!isMapping(parsed)) throw new TermError("vale printed a configuration that is not a JSON object.");
+  const paths = stringList(parsed["Paths"]);
+  const stylesPath = paths?.[paths.length - 1];
+  if (stylesPath === void 0 || stylesPath === "") {
+    throw new TermError(
+      "vale's configuration names no styles directory. Set StylesPath in it, or pass -o <styles directory>."
+    );
+  }
+  const root = parsed["RootINI"];
+  const configFiles = stringList(parsed["ConfigFiles"]);
+  const rootIni = typeof root === "string" && root !== "" ? root : configFiles?.[configFiles.length - 1] ?? opts.config ?? "";
+  const baseStyles = {};
+  const sections = parsed["SBaseStyles"];
+  if (sections !== null && sections !== void 0) {
+    if (!isMapping(sections)) throw new TermError("vale printed SBaseStyles that is not a JSON object.");
+    for (const [glob, styles] of Object.entries(sections)) {
+      const list = stringList(styles);
+      if (list === void 0) throw new TermError(`vale printed styles for ${glob} that are not a list of names.`);
+      baseStyles[glob] = list;
+    }
+  }
+  return { stylesPath, rootIni, baseStyles };
+}
+
+// src/term/core/lint.ts
+var PROSE_FIELDS = ["definition", "abstract", "scope-note"];
+function fileStem(id) {
+  const safe = id.replace(/[^A-Za-z0-9._-]/g, "_");
+  return safe === "" ? "_" : safe;
+}
+function baseName(path) {
+  const parts = path.split(/[\\/]/);
+  return parts[parts.length - 1] ?? path;
+}
+function sourceLine(written, proseLine) {
+  const { term, field, value } = written;
+  const fieldLine = term.location.fieldLines[field] ?? term.location.line;
+  if (!value.includes("\n")) return fieldLine;
+  const { construct } = term.location;
+  return construct === "page" || construct === "manifest" ? fieldLine + proseLine : fieldLine + proseLine - 1;
+}
+function compareFindings(a, b) {
+  if (a.file !== b.file) return a.file < b.file ? -1 : 1;
+  const lineA = a.line ?? 0;
+  const lineB = b.line ?? 0;
+  if (lineA !== lineB) return lineA - lineB;
+  if (a.ruleId !== b.ruleId) return a.ruleId < b.ruleId ? -1 : 1;
+  if (a.message !== b.message) return a.message < b.message ? -1 : 1;
+  return 0;
+}
+async function lintTermSet(set, opts = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  const files = [];
+  const stemCount = /* @__PURE__ */ new Map();
+  for (const term of set.terms) {
+    const fields = PROSE_FIELDS.filter((field) => term.record[field] !== void 0);
+    if (fields.length === 0) continue;
+    const stem = fileStem(term.id);
+    const seen = (stemCount.get(stem.toLowerCase()) ?? 0) + 1;
+    stemCount.set(stem.toLowerCase(), seen);
+    const prefix = seen === 1 ? stem : `${stem}.${String(seen)}`;
+    for (const field of fields) {
+      const value = term.record[field];
+      if (value === void 0) continue;
+      const name = `${prefix}.${field}.md`;
+      byName.set(name.toLowerCase(), { term, field, value });
+      files.push({ name, content: `${value}
+` });
+    }
+  }
+  if (files.length === 0) return [];
+  const runVale = opts.runVale ?? runValeJson;
+  const dir = await mkdtemp(join3(tmpdir(), "manni-term-lint-"));
+  try {
+    for (const file of files) await writeFile(join3(dir, file.name), file.content, "utf8");
+    const alerts = await runVale([dir], { config: opts.valeConfig, cwd: opts.cwd });
+    const findings = [];
+    for (const [path, list] of Object.entries(alerts)) {
+      const written = byName.get(baseName(path).toLowerCase());
+      if (written === void 0) continue;
+      for (const alert of list) {
+        findings.push({
+          ruleId: proseRuleId(alert.Check),
+          severity: foldValeSeverity(alert.Severity),
+          message: alert.Message,
+          file: written.term.location.file,
+          line: sourceLine(written, alert.Line),
+          id: written.term.id,
+          tool: "vale",
+          check: alert.Check,
+          toolSeverity: alert.Severity,
+          field: written.field
+        });
+      }
+    }
+    return findings.sort(compareFindings);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+// src/term/commands/lint.ts
+async function runLint(opts) {
+  const { cwd, run, set } = await loadTerms(opts);
+  const valeConfig = valeConfigFor(run);
+  const findings = await lintTermSet(set, {
+    cwd,
+    ...valeConfig === void 0 ? {} : { valeConfig },
+    ...opts.runVale === void 0 ? {} : { runVale: opts.runVale }
+  });
+  const { results, origin } = toResults(set, findings);
+  return {
+    findings: reportedFindings(results, origin),
+    results,
+    summary: summarize(results),
+    frame: { cwd, base: run.configDir ?? cwd, runBase: run.base },
+    terms: set.terms.length,
+    references: set.references.length,
+    found: findings.length,
+    cwd
+  };
+}
+
+// src/term/commands/write.ts
+import { existsSync, statSync } from "node:fs";
+import { lstat, mkdir, readdir, readFile, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, extname, join as join4, resolve as resolve2 } from "node:path";
+var SUGGESTED_SECTION = "*.md";
+var STYLE2 = "Terms";
+function writeFormats(writers = TERM_WRITERS) {
+  return TERM_WRITE_FORMATS.filter((format) => writers.some((writer) => writer.format === format));
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var MAX_EXISTING_FILE_BYTES = 1024 * 1024;
+async function filesUnder(dir, into) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const path = join4(dir, entry.name);
+    if (entry.isDirectory()) await filesUnder(path, into);
+    else if (entry.isFile()) {
+      const { size } = await lstat(path);
+      into.set(path, size > MAX_EXISTING_FILE_BYTES ? "" : await readFile(path, "utf8"));
+    }
+  }
+}
+async function existingFor(target) {
+  const existing = /* @__PURE__ */ new Map();
+  if (target.shape === "directory") {
+    await filesUnder(target.path, existing);
+  } else if (existsSync(target.path) && !isDirectory(target.path)) {
+    existing.set(target.path, await readFile(target.path, "utf8"));
+  }
+  return existing;
+}
+function relativized(error, paths, cwd) {
+  let message = error.message;
+  for (const path of [...paths].sort((a, b) => b.length - a.length)) {
+    if (message.includes(path)) message = message.replaceAll(path, displayPath(path, cwd));
+  }
+  return message === error.message ? error : new TermError(message);
+}
+function droppedFrom(format, shape, readers) {
+  const construct = DOCUMENT_RENDERS[format]?.shapes[shape];
+  const reader = construct === void 0 ? void 0 : readerForConstruct(construct, readers);
+  return reader === void 0 ? format : `a ${reader.label}`;
+}
+async function applyChanges(files, removals, existing, cwd, write) {
+  const changes = [];
+  for (const file of files) {
+    const before = existing.get(file.path) ?? (existsSync(file.path) ? await readFile(file.path, "utf8") : void 0);
+    if (before === file.content) continue;
+    changes.push({ path: displayPath(file.path, cwd), action: before === void 0 ? "create" : "change" });
+    if (write) {
+      await mkdir(dirname(file.path), { recursive: true });
+      await writeFile2(file.path, file.content, "utf8");
+    }
+  }
+  for (const path of removals) {
+    if (!existsSync(path)) continue;
+    changes.push({ path: displayPath(path, cwd), action: "remove" });
+    if (write) await rm2(path, { force: true });
+  }
+  return changes;
+}
+async function runWrite(opts) {
+  const cwd = resolve2(opts.cwd ?? process.cwd());
+  const writers = opts.writers ?? TERM_WRITERS;
+  const readers = opts.readers ?? TERM_READERS;
+  const check = opts.check === true;
+  const dryRun = opts.dryRun === true;
+  if (check && dryRun) throw new TermError("--check and --dry-run cannot be combined.");
+  if (opts.format === void 0) {
+    if (opts.out !== void 0) throw new TermError("-o needs -f <format>.");
+    return writeInPlace({ ...opts, cwd, readers }, check, dryRun);
+  }
+  const format = formatChoice(opts.format, writeFormats(writers));
+  const writer = writers.find((w) => w.format === format);
+  if (writer === void 0) throw new TermError(`unknown format "${format}".`);
+  if (opts.out === void 0 && format !== "vale") {
+    throw new TermError(`-f ${format} needs -o <path>.`);
+  }
+  const { run, set } = await loadTerms({ ...opts, cwd, readers });
+  let targetPath;
+  let wiring;
+  if (opts.out === void 0) {
+    const lsConfig = opts.lsConfig ?? ((o) => valeLsConfig(o));
+    const config = valeConfigFor(run);
+    const resolved = await lsConfig({ cwd, ...config === void 0 ? {} : { config } });
+    if (resolved === null) {
+      throw new TermError(
+        "Vale found no config file. Set tools.vale.config in manni.config.yaml, or pass -o <styles directory>."
+      );
+    }
+    targetPath = resolve2(cwd, resolved.stylesPath);
+    if (!Object.values(resolved.baseStyles).some((styles) => styles.includes(STYLE2))) {
+      const first = Object.entries(resolved.baseStyles)[0];
+      const [section, styles] = first ?? [SUGGESTED_SECTION, []];
+      wiring = {
+        rootIni: displayPath(resolve2(cwd, resolved.rootIni), cwd),
+        section,
+        styles: [...styles, STYLE2],
+        addSection: first === void 0
+      };
+    }
+  } else {
+    targetPath = resolve2(cwd, opts.out);
+  }
+  const shape = format === "vale" || /[\\/]$/.test(opts.out ?? "") || isDirectory(targetPath) ? "directory" : "file";
+  const target = { path: targetPath, shape };
+  const existing = await existingFor(target);
+  let render;
+  try {
+    render = writer.render(set.terms, target, { existing });
+  } catch (error) {
+    if (error instanceof TermError) throw relativized(error, [...existing.keys(), targetPath], cwd);
+    throw error;
+  }
+  const changes = await applyChanges(render.files, render.removals, existing, cwd, !check && !dryRun);
+  const shown = format === "vale" ? displayPath(join4(targetPath, STYLE2), cwd) : opts.out ?? displayPath(targetPath, cwd);
+  return {
+    mode: "render",
+    format,
+    shape,
+    target: shown,
+    terms: set.terms.length,
+    changes,
+    files: render.files.map((file) => ({ path: displayPath(file.path, cwd), content: file.content })),
+    // A Vale style holds designations only, by design; its dropped definitions are not news.
+    dropped: format === "vale" ? [] : render.dropped,
+    droppedFrom: droppedFrom(format, shape, readers),
+    skipped: render.skipped,
+    check,
+    dryRun,
+    ...wiring === void 0 ? {} : { wiring }
+  };
+}
+function inputFor(content, path, construct, file) {
+  if (construct === "manifest") {
+    return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
+  }
+  const extractor = extractorForExtension(extname(path));
+  if (extractor === void 0) throw new TermError(`${file}: no reader for its extension.`);
+  return extractInput(content, file, path, extractor.name);
+}
+function carryRecords(current, edited) {
+  const count = (terms, id) => terms.filter((t) => t.id === id).length;
+  return current.map((entry, index) => {
+    const unique = count(current, entry.id) === 1 && count(edited, entry.id) === 1;
+    const match = unique ? edited.find((t) => t.id === entry.id) : edited[index];
+    return match?.id === entry.id ? { ...entry, record: match.record } : entry;
+  });
+}
+function applyInPlace(original, path, file, constructs, readers) {
+  let content = original;
+  let first = true;
+  for (const [construct, terms] of constructs) {
+    const reader = readerForConstruct(construct, readers);
+    if (reader?.apply === void 0) continue;
+    const input = inputFor(content, path, construct, file);
+    content = reader.apply(input, first ? terms : carryRecords(reader.read(input).terms, terms));
+    first = false;
+  }
+  return content;
+}
+async function writeInPlace(opts, check, dryRun) {
+  const { cwd, readers } = opts;
+  const { set } = await loadTerms(opts);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const term of set.terms) {
+    const { path, construct } = term.location;
+    if (path === void 0) {
+      throw new TermError(`${term.location.file} has nowhere to write back to. Pass -f <format> -o <path>.`);
+    }
+    const reader = readerForConstruct(construct, readers);
+    if (reader?.apply === void 0) {
+      const name = reader?.label ?? construct;
+      throw new TermError(
+        `${displayPath(term.location.file, cwd)}: a ${name} cannot be written in place. Pass -f <format> -o <path>.`
+      );
+    }
+    const entry = byPath.get(path) ?? { file: term.location.file, constructs: /* @__PURE__ */ new Map() };
+    entry.constructs.set(construct, [...entry.constructs.get(construct) ?? [], term]);
+    byPath.set(path, entry);
+  }
+  const files = [];
+  const existing = /* @__PURE__ */ new Map();
+  for (const [path, { file, constructs }] of byPath) {
+    let original;
+    try {
+      original = await readFile(path, "utf8");
+    } catch (error) {
+      throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+    }
+    existing.set(path, original);
+    files.push({ path, content: applyInPlace(original, path, file, constructs, readers) });
+  }
+  const changes = await applyChanges(files, [], existing, cwd, !check && !dryRun);
+  return {
+    mode: "in-place",
+    terms: set.terms.length,
+    changes,
+    files: files.map((f) => ({ path: displayPath(f.path, cwd), content: f.content })),
+    dropped: [],
+    skipped: [],
+    check,
+    dryRun
+  };
+}
+
+// src/term/reporters/csv.ts
+var LIST_SEPARATOR2 = "|";
+function cell2(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+function renderListCsv(terms) {
+  const rows = [
+    ["id", "label", "alt-labels", "abstract"],
+    ...terms.map((t) => [
+      t.id,
+      t.record.label,
+      (t.record["alt-labels"] ?? []).join(LIST_SEPARATOR2),
+      t.record.abstract ?? ""
+    ])
+  ];
+  return rows.map((row) => row.map(cell2).join(",")).join("\n");
+}
+
+// src/term/reporters/sarif.ts
+var INFORMATION_URI = "https://hawkeyexl.github.io/manni/term/";
+var RULES_URI = "https://hawkeyexl.github.io/manni/term/reference/rules/";
+var RULE_DESCRIPTIONS = {
+  "undefined-term": "A page's concepts: names a label no entry claims as its preferred label.",
+  "duplicate-id": "Two entries share an id.",
+  "label-collision": "Two entries claim the same preferred label, ignoring case.",
+  "alt-label-collision": "An entry's alt-label is another entry's preferred label, ignoring case.",
+  "dangling-reference": "A value of broader, narrower, related-terms or see names no entry, by label or by id.",
+  "broader-cycle": "A chain of broader returns to where it started.",
+  "see-not-empty": "An entry with see also carries a definition.",
+  "asymmetric-hierarchy": "A names B as broader, and B omits A from narrower, or the reverse.",
+  "abstract-too-long": "An abstract is longer than term.abstractMaxLength.",
+  "unused-term": "No page's concepts: names the entry's preferred label."
+};
+var PROSE_PREFIX = `${RULE_ID_PREFIX}/prose/`;
+var FIELD_LABEL = new RegExp(`^(?:\\(root\\)|/(?:${TERM_FIELDS.join("|")})) `);
+function describe(rule) {
+  if (rule.id.startsWith(PROSE_PREFIX)) {
+    const check = rule.id.slice(PROSE_PREFIX.length);
+    return { id: rule.id, shortDescription: { text: `Vale's ${check} rule flagged the prose of an entry's field.` } };
+  }
+  const name = rule.id.slice(RULE_ID_PREFIX.length + 1);
+  if (!isTermRule(name)) return rule;
+  return { id: rule.id, shortDescription: { text: RULE_DESCRIPTIONS[name] }, helpUri: `${RULES_URI}#${name}` };
+}
+function renderFindingsSarif(report, opts = {}) {
+  const log = JSON.parse(
+    renderSarif(report.results, {
+      frame: report.frame,
+      ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice }
+    })
+  );
+  for (const run of log.runs) {
+    run.tool.driver.informationUri = INFORMATION_URI;
+    run.tool.driver.rules = run.tool.driver.rules.map(describe);
+    for (const result of run.results) result.message.text = result.message.text.replace(FIELD_LABEL, "");
+  }
+  return JSON.stringify(log, null, 2);
+}
+
+// src/term/reporters/junit.ts
+var MESSAGE_LABEL = new RegExp(`message="${FIELD_LABEL.source.slice(1)}`, "g");
+function renderFindingsJunit(report) {
+  return renderJunit(report.results, { frame: report.frame, classname: JUNIT_CLASSNAME }).replace(
+    MESSAGE_LABEL,
+    'message="'
+  );
+}
+
+// src/term/commands/labels.ts
+async function termLabels(request) {
+  const run = await resolveTermRun({
+    cwd: request.cwd,
+    inputs: [],
+    ...request.configPath === void 0 ? {} : { configPath: request.configPath },
+    ...request.noConfig === true ? { noConfig: true } : {}
+  });
+  if (run.inputs.length === 0 && run.manifests.length === 0) return [];
+  const set = await loadSet(run, { inputs: [], allowEmpty: true });
+  return set.terms.map((term) => ({ label: term.record.label, id: term.id }));
+}
+
+// src/term/cli.ts
+registerTermLabelSource(termLabels);
+function colorFor(options) {
+  return shouldColor({ noColor: !options.color, isTTY: process.stdout.isTTY });
+}
+async function coreOptions(paths, options) {
+  return {
+    inputs: paths,
+    ...paths.includes(STDIN_TOKEN) ? { stdin: await readStdin() } : {},
+    ...options.as === void 0 ? {} : { as: options.as },
+    ...options.ext === void 0 ? {} : { exts: splitList(options.ext) },
+    exclude: options.exclude,
+    collection: options.collection,
+    ...options.allowEmpty === true ? { allowEmpty: true } : {},
+    ...options.gitignore ? {} : { noGitignore: true },
+    ...options.config === void 0 ? {} : { configPath: options.config },
+    onNotice: notice
+  };
+}
+function withInputs(command) {
+  return command.option("--as <format>", "input format for stdin (-)").option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--collection <name>", "configured collection to read; repeatable", collect, []).option("--allow-empty", "treat a missing path, no matched files or no terms as success").option("--no-gitignore", "read files .gitignore covers").option("-c, --config <path>", "path to a manni config file").option("--no-color", "disable colored output");
+}
+function print(text2) {
+  process.stdout.write(`${text2}
+`);
+}
+function renderFindings(report, format, options, references2) {
+  let text2;
+  switch (format) {
+    case "pretty":
+      text2 = renderFindingsPretty(report, { color: colorFor(options), references: references2 });
+      break;
+    case "json":
+      text2 = renderFindingsJson(report);
+      break;
+    case "github":
+      text2 = renderFindingsGithub(report);
+      break;
+    case "sarif":
+      text2 = renderFindingsSarif(report, { onNotice: notice });
+      break;
+    case "junit":
+      text2 = renderFindingsJunit(report);
+      break;
+  }
+  if (text2.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) print(text2);
+  process.exitCode = report.summary.failed > 0 ? 1 : 0;
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("term").description("Check, lint and render a docset's terms and the references into them.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride();
+  withInputs(
+    program.command("list").description("List the resolved entries").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${LIST_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term list                       # every collection",
+      "  manni term list docs/terms/           # one directory",
+      "  manni term list -f csv | head -2      # for a script"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, LIST_FORMATS);
+      const { terms } = await runList(await coreOptions(paths, options));
+      print(format === "json" ? renderListJson(terms) : format === "csv" ? renderListCsv(terms) : renderListPretty(terms));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("get").description("Show one entry").argument("<term>", "the entry's id, or its label or an alt-label in any case").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${GET_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    ["", "Examples:", "  manni term get progressive-lens", '  manni term get "progressive lens" -f json'].join("\n")
+  ).action(async (term, paths, options) => {
+    try {
+      const format = formatChoice(options.format, GET_FORMATS);
+      const found = await runGet({ ...await coreOptions(paths, options), term });
+      print(format === "json" ? renderGetJson(found) : renderGetPretty(found, { color: colorFor(options) }));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("check").description("Check the set and every reference into it").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${FINDING_FORMATS.join(" | ")}`, "pretty").option("--baseline", "record the findings on the first run; after that, fail only on new ones").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term check                      # every collection",
+      "  manni term check -f github            # CI annotations",
+      "  manni term check --baseline           # ramp in on an existing docset"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, FINDING_FORMATS);
+      const report = await runCheck({
+        ...await coreOptions(paths, options),
+        ...options.baseline === true ? { baseline: true } : {}
+      });
+      renderFindings(report, format, options, true);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("lint").description("Run Vale over the definitions").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${FINDING_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    ["", "Examples:", "  manni term lint", "  manni term lint -f github"].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, FINDING_FORMATS);
+      const report = await runLint(await coreOptions(paths, options));
+      renderFindings(report, format, options, false);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("write").description("Write the set back, or render it elsewhere").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `render as: ${writeFormats().join(" | ")} (default: each entry's own, in place)`).option("-o, --out <path>", "file or directory to render into; a trailing / means a directory").option("--check", "write nothing; exit 1 when the target differs from the render").option("--dry-run", "write nothing; print what would change").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term write                            # each entry back to its source",
+      "  manni term write -f json -o build/terms.json",
+      "  manni term write -f vale                    # into Vale's styles directory",
+      "  manni term write -f vale --check            # keep the style in step"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const report = await runWrite({
+        ...await coreOptions(paths, options),
+        ...options.format === void 0 ? {} : { format: options.format },
+        ...options.out === void 0 ? {} : { out: options.out },
+        ...options.check === true ? { check: true } : {},
+        ...options.dryRun === true ? { dryRun: true } : {}
+      });
+      print(renderWritePretty(report));
+      if (report.wiring !== void 0) process.stderr.write(`${renderValeWiring(report.wiring)}
+`);
+      process.exitCode = report.check && report.changes.length > 0 ? 1 : 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  program.command("formats").description("List the constructs read and written, per format").option("-f, --format <format>", `output: ${FORMATS_FORMATS.join(" | ")}`, "pretty").action((options) => {
+    try {
+      const format = formatChoice(options.format, FORMATS_FORMATS);
+      const rows = listFormats();
+      print(format === "json" ? renderFormatsJson(rows) : renderFormatsPretty(rows));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  return program;
+}
+export {
+  TERM_RULES,
+  TermError,
+  buildProgram
+};
+//# sourceMappingURL=term-5ICGKPC3.js.map