@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/chunk-PU6DFJMY.js

@@ -0,0 +1,1975 @@
+#!/usr/bin/env node
+import {
+  SEVERITIES
+} from "./chunk-77AINBYM.js";
+import {
+  codeEndAt,
+  codeRegions
+} from "./chunk-IKEWBMCN.js";
+import {
+  CONCEPT_FIELDS,
+  fieldPointer,
+  valueAt
+} from "./chunk-6JSSEWBG.js";
+import {
+  STDIN_LABEL,
+  STDIN_TOKEN,
+  assertNonEmpty,
+  extractorByName,
+  extractorForExtension,
+  gitignoreOptions,
+  locateFrontmatter,
+  resolveTargetSet
+} from "./chunk-57NEQRVO.js";
+import {
+  findConfigFile,
+  readConfigFile,
+  selectCollections,
+  valeConfigPath
+} from "./chunk-Q35YIDBV.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/term/errors.ts
+var TermError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "TermError";
+  }
+};
+
+// src/term/types.ts
+var TERM_FIELDS = [
+  "label",
+  "definition",
+  "abstract",
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms",
+  "see",
+  "scope-note"
+];
+var TERM_LIST_FIELDS = [
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms"
+];
+var TERM_WRITE_FORMATS = [
+  "markdown",
+  "mdx",
+  "asciidoc",
+  "rst",
+  "html",
+  "dita",
+  "docbook",
+  "tbx",
+  "skos",
+  "csv",
+  "json",
+  "vale"
+];
+var TERM_RULES = [
+  "undefined-term",
+  "duplicate-id",
+  "label-collision",
+  "alt-label-collision",
+  "dangling-reference",
+  "broader-cycle",
+  "see-not-empty",
+  "asymmetric-hierarchy",
+  "abstract-too-long",
+  "unused-term"
+];
+
+// src/term/core/config.ts
+import { resolve } from "node:path";
+var TERM_SECTION = "term";
+var DEFAULT_TERM_BASELINE_PATH = ".manni-term-baseline.json";
+var DEFAULT_ABSTRACT_MAX_LENGTH = 60;
+var CONFIG_KEYS = [
+  "manifests",
+  "abstractMaxLength",
+  "baseline",
+  "severity",
+  "allowEmpty",
+  "respectGitignore"
+];
+var COLLECTION_KEYS = ["paths", "exclude"];
+var TOOL_KEYS = ["vale"];
+var SEVERITY_LEVELS = [...SEVERITIES, "off"];
+var CONFIG_FILE = {
+  section: TERM_SECTION,
+  legacyNames: [],
+  toError: (message) => new TermError(message)
+};
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLevel(value) {
+  return typeof value === "string" && SEVERITY_LEVELS.includes(value);
+}
+function isTermRule(value) {
+  return TERM_RULES.includes(value);
+}
+function rejectUnknownKeys(obj, allowed, where, source) {
+  for (const key of Object.keys(obj)) {
+    if (!allowed.includes(key)) {
+      throw new TermError(
+        `Unknown key "${key}" under ${where}: in ${source}. Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function wrongType(key, expected, source) {
+  return new TermError(`term.${key} in ${source} must be ${expected}.`);
+}
+function asBoolean(value, key, source) {
+  if (typeof value !== "boolean") throw wrongType(key, "a boolean", source);
+  return value;
+}
+function asString(value, key, source) {
+  if (typeof value !== "string") throw wrongType(key, "a string", source);
+  return value;
+}
+function asStringList(value, key, source) {
+  if (!Array.isArray(value) || !value.every((item2) => typeof item2 === "string" && item2.trim() !== "")) {
+    throw wrongType(key, "a list of non-empty strings", source);
+  }
+  return value;
+}
+function asNonNegativeInteger(value, key, source) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw wrongType(key, "a non-negative integer", source);
+  }
+  return value;
+}
+function parseSeverity(value, source) {
+  if (!isMapping(value)) throw wrongType("severity", "a mapping", source);
+  rejectUnknownKeys(value, TERM_RULES, "term.severity", source);
+  const severity = {};
+  for (const [rule, level] of Object.entries(value)) {
+    if (!isTermRule(rule)) continue;
+    if (!isLevel(level)) {
+      const quoted = typeof level === "string" ? ` "${level}"` : "";
+      throw new TermError(
+        `${source}: term.severity.${rule}${quoted} is not a level. Expected ${SEVERITY_LEVELS.join(" | ")}.`
+      );
+    }
+    severity[rule] = level;
+  }
+  return severity;
+}
+function parseTermConfig(raw, source) {
+  if (raw == null) return {};
+  if (!isMapping(raw)) {
+    throw new TermError(`term: in ${source} must be a mapping.`);
+  }
+  for (const key of COLLECTION_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new TermError(
+        `${source}: term does not carry "${key}". Name a collection under collections:.`
+      );
+    }
+  }
+  for (const key of TOOL_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new TermError(
+        `${source}: term does not carry "${key}". Vale's settings live under tools.${key}.`
+      );
+    }
+  }
+  rejectUnknownKeys(raw, CONFIG_KEYS, "term", source);
+  const config = {};
+  if (raw.manifests !== void 0) config.manifests = asStringList(raw.manifests, "manifests", source);
+  if (raw.abstractMaxLength !== void 0) {
+    config.abstractMaxLength = asNonNegativeInteger(raw.abstractMaxLength, "abstractMaxLength", source);
+  }
+  if (raw.baseline !== void 0) config.baseline = asString(raw.baseline, "baseline", source);
+  if (raw.severity !== void 0) config.severity = parseSeverity(raw.severity, source);
+  if (raw.allowEmpty !== void 0) config.allowEmpty = asBoolean(raw.allowEmpty, "allowEmpty", source);
+  if (raw.respectGitignore !== void 0) {
+    config.respectGitignore = asBoolean(raw.respectGitignore, "respectGitignore", source);
+  }
+  return config;
+}
+function readTermConfigFile(explicitPath, cwd) {
+  return explicitPath ? readConfigFile(explicitPath, cwd, CONFIG_FILE) : findConfigFile(cwd, CONFIG_FILE);
+}
+function toLoaded(file) {
+  return {
+    config: parseTermConfig(file.value, file.source),
+    path: file.path,
+    dir: file.dir,
+    source: file.source,
+    collections: file.collections,
+    tools: file.tools
+  };
+}
+var STDIN = "-";
+async function resolveTermRun(opts) {
+  const cwd = resolve(opts.cwd);
+  const wanted = opts.collection ?? [];
+  if (wanted.length > 0 && opts.inputs.some((input) => input !== STDIN)) {
+    throw new TermError(
+      "--collection selects a configured collection; it cannot be combined with paths."
+    );
+  }
+  const file = opts.noConfig ? null : await readTermConfigFile(opts.configPath, cwd);
+  const loaded = file === null ? null : toLoaded(file);
+  if (wanted.length > 0 && loaded === null) {
+    throw new TermError("--collection needs a config file to select from.");
+  }
+  if (loaded) opts.onConfigLoaded?.({ path: loaded.path, dir: loaded.dir });
+  const collections = loaded ? selectCollections(loaded.collections, wanted, loaded.source, (message) => new TermError(message)) : [];
+  const fromCollections = opts.inputs.length === 0;
+  const inputs = fromCollections ? collections.flatMap((c) => c.paths) : opts.inputs;
+  const base = fromCollections && inputs.length > 0 && loaded ? loaded.dir : cwd;
+  const manifests = loaded ? (loaded.config.manifests ?? []).map((written) => ({ path: resolve(loaded.dir, written), written })) : [];
+  return {
+    config: loaded ? loaded.config : null,
+    inputs,
+    base,
+    collections,
+    fromCollections,
+    manifests,
+    tools: loaded ? loaded.tools : {},
+    ...loaded ? { configDir: loaded.dir, configPath: loaded.path, configSource: loaded.source } : {},
+    ...file === null ? {} : { configFile: file }
+  };
+}
+
+// src/term/commands/run.ts
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve as resolve3 } from "node:path";
+
+// src/term/core/load-set.ts
+import { readFile } from "node:fs/promises";
+import { extname, resolve as resolve2 } from "node:path";
+
+// src/term/core/writers/markup.ts
+function xmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function xmlAttribute(value) {
+  return xmlText(value).replaceAll('"', "&quot;");
+}
+function paragraphsOf(definition) {
+  if (definition === void 0) return [];
+  return definition.split(/\r?\n[ \t]*\r?\n/).map(
+    (paragraph) => paragraph.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "")
+  ).filter((lines) => lines.length > 0);
+}
+function paragraphText(lines) {
+  return lines.join(" ");
+}
+function isAcronym(label) {
+  return new RegExp("\\p{L}", "u").test(label) && !new RegExp("\\p{Ll}", "u").test(label);
+}
+function sharedLanguage(terms) {
+  const [first] = terms;
+  const language = first?.language;
+  if (language === void 0) return void 0;
+  return terms.every((t) => t.language === language) ? language : void 0;
+}
+function reindent(text, indent, eol) {
+  return text.split("\n").map((line, i) => i === 0 || line === "" ? line : `${indent}${line}`).join(eol);
+}
+function fileOf(lines) {
+  return lines.map((line) => `${line}
+`).join("");
+}
+
+// src/term/core/writers/entries.ts
+var LIST_HOLDS = ["label", "definition", "alt-labels"];
+var DITA_HOLDS = ["label", "definition", "alt-labels", "scope-note"];
+var DOCBOOK_HOLDS = ["label", "definition", "alt-labels", "see", "related-terms"];
+function labelsOf(record) {
+  return [record.label, ...record["alt-labels"] ?? []];
+}
+function markdownEntry(record) {
+  const lines = labelsOf(record);
+  const paragraphs = paragraphsOf(record.definition);
+  if (paragraphs.length === 0) return [...lines, ":"].join("\n");
+  paragraphs.forEach((paragraph, p) => {
+    if (p > 0) lines.push("");
+    paragraph.forEach((line, i) => {
+      lines.push(p === 0 && i === 0 ? `:   ${line}` : `    ${line}`);
+    });
+  });
+  return lines.join("\n");
+}
+function asciidocEntry(record) {
+  const labels = labelsOf(record);
+  const paragraphs = paragraphsOf(record.definition);
+  const lines = labels.map((label) => `${label}::`);
+  paragraphs.forEach((paragraph, p) => {
+    if (p > 0) lines.push("+");
+    paragraph.forEach((line, i) => {
+      if (p === 0 && i === 0) lines[lines.length - 1] = `${lines[lines.length - 1] ?? ""} ${line}`;
+      else lines.push(line);
+    });
+  });
+  return lines.join("\n");
+}
+function rstEntry(record) {
+  const lines = labelsOf(record);
+  paragraphsOf(record.definition).forEach((paragraph, p) => {
+    if (p > 0) lines.push("");
+    for (const line of paragraph) lines.push(`   ${line}`);
+  });
+  return lines.join("\n");
+}
+function blockDefinition(open, close, paragraph, definition) {
+  const paragraphs = paragraphsOf(definition);
+  const [only] = paragraphs;
+  if (only === void 0) return [];
+  if (paragraphs.length === 1) return [`${open}${xmlText(paragraphText(only))}${close}`];
+  return [
+    open,
+    ...paragraphs.map((lines) => `  <${paragraph}>${xmlText(paragraphText(lines))}</${paragraph}>`),
+    close
+  ];
+}
+function htmlDlEntry(term) {
+  const [label, ...alts] = labelsOf(term.record);
+  return [
+    `<dt id="${xmlAttribute(term.id)}">${xmlText(label ?? "")}</dt>`,
+    ...alts.map((alt) => `<dt>${xmlText(alt)}</dt>`),
+    ...blockDefinition("<dd>", "</dd>", "p", term.record.definition)
+  ].join("\n");
+}
+function ditaEntry(term, language) {
+  const { record } = term;
+  const alts = record["alt-labels"] ?? [];
+  const scopeNote = record["scope-note"];
+  const lang = language === void 0 ? "" : ` xml:lang="${xmlAttribute(language)}"`;
+  const body = scopeNote === void 0 && alts.length === 0 ? [] : [
+    "  <glossBody>",
+    ...scopeNote === void 0 ? [] : [`    <glossUsage>${xmlText(scopeNote)}</glossUsage>`],
+    ...alts.flatMap((alt) => {
+      const element = isAcronym(alt) ? "glossAcronym" : "glossSynonym";
+      return ["    <glossAlt>", `      <${element}>${xmlText(alt)}</${element}>`, "    </glossAlt>"];
+    }),
+    "  </glossBody>"
+  ];
+  return [
+    `<glossentry id="${xmlAttribute(term.id)}"${lang}>`,
+    `  <glossterm>${xmlText(record.label)}</glossterm>`,
+    ...blockDefinition("<glossdef>", "</glossdef>", "p", record.definition).map((line) => `  ${line}`),
+    ...body,
+    "</glossentry>"
+  ].join("\n");
+}
+function docbookEntry(term) {
+  const { record } = term;
+  const related = record["related-terms"] ?? [];
+  const paragraphs = paragraphsOf(record.definition);
+  const glossdef = paragraphs.length === 0 && related.length === 0 ? [] : [
+    "  <glossdef>",
+    ...paragraphs.map((lines) => `    <para>${xmlText(paragraphText(lines))}</para>`),
+    ...related.map((target) => `    <glossseealso>${xmlText(target)}</glossseealso>`),
+    "  </glossdef>"
+  ];
+  return [
+    `<glossentry xml:id="${xmlAttribute(term.id)}">`,
+    `  <glossterm>${xmlText(record.label)}</glossterm>`,
+    ...(record["alt-labels"] ?? []).map(
+      (alt) => isAcronym(alt) ? `  <acronym>${xmlText(alt)}</acronym>` : `  <glossterm>${xmlText(alt)}</glossterm>`
+    ),
+    ...glossdef,
+    ...record.see === void 0 ? [] : [`  <glosssee>${xmlText(record.see)}</glosssee>`],
+    "</glossentry>"
+  ].join("\n");
+}
+
+// src/term/core/id.ts
+import { slug } from "github-slugger";
+function slugOf(label) {
+  return slug(label.trim());
+}
+
+// src/term/core/readers/normalize.ts
+function nothing() {
+  return { terms: [], notices: [] };
+}
+function textOf(value) {
+  let text;
+  if (typeof value === "string") text = value;
+  else if (typeof value === "number" && Number.isFinite(value)) text = String(value);
+  else return void 0;
+  const trimmed = text.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function listOf(value) {
+  const items = Array.isArray(value) ? value : [value];
+  const list = items.map(textOf).filter((item2) => item2 !== void 0);
+  return list.length === 0 ? void 0 : list;
+}
+function collapse(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isListField(field) {
+  return TERM_LIST_FIELDS.includes(field);
+}
+function recordOf(raw) {
+  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]);
+      if (list !== void 0) record[field] = list;
+    } else if (field !== "label") {
+      const text = textOf(raw[field]);
+      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) {
+    const line = lines[field];
+    if (line !== void 0 && record[field] !== void 0) kept[field] = line;
+  }
+  return kept;
+}
+function idFor(record, recordId, constructId) {
+  return textOf(recordId) ?? textOf(constructId) ?? slugOf(record.label);
+}
+function languageOf(input) {
+  return textOf(input.metadata["language"]) ?? textOf(input.metadata["xml:lang"]);
+}
+function declares(input, type) {
+  const value = input.metadata["type"];
+  return typeof value === "string" && value.trim() === type;
+}
+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 location = {
+    file: input.file,
+    ...input.path === void 0 ? {} : { path: input.path },
+    construct: parts.construct,
+    line: parts.line,
+    fieldLines: linesFor(parts.record, parts.lines),
+    ...parts.span === void 0 ? {} : { span: parts.span }
+  };
+  return {
+    id: idFor(parts.record, parts.recordId, parts.constructId),
+    record: parts.record,
+    ...language === void 0 ? {} : { language },
+    location
+  };
+}
+
+// src/term/core/readers/splice.ts
+function sameValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function sameFields(a, b, fields) {
+  return fields.every((field) => sameValue(a[field], b[field]));
+}
+function lineEnding(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function indentAt(content, offset) {
+  const lineStart = content.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(content.slice(lineStart, offset))?.[0] ?? "";
+}
+function applyEntries(input, read8, terms, write) {
+  const { content } = input;
+  const current = read8(input).terms;
+  const eol = lineEnding(content);
+  const edits = [];
+  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 found = current.find((t) => t.location.span?.start === span.start && t.location.span.end === span.end);
+    if (found === void 0) {
+      throw new TermError(
+        `${input.file}: term "${term.id}" does not match an entry in the file. Read the file again before writing it.`
+      );
+    }
+    if (sameFields(found.record, term.record, write.holds) && (!write.id || found.id === term.id)) continue;
+    const text = reindent(write.serialize(term, input), indentAt(content, span.start), eol);
+    edits.push({ start: span.start, end: span.end, text });
+  }
+  let next = content;
+  for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+  }
+  return next;
+}
+
+// src/term/core/readers/xml.ts
+import { DOMParser } from "@xmldom/xmldom";
+var cache = /* @__PURE__ */ new WeakMap();
+var LINE_BREAK = /\r\n|\r|\n|\u0085|\u2028|\u2029/g;
+function lineStarts(source) {
+  const starts = [0];
+  for (const match of source.matchAll(LINE_BREAK)) starts.push(match.index + match[0].length);
+  return starts;
+}
+function parseXml(input) {
+  const cached = cache.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 parsed = null;
+  try {
+    const doc = new DOMParser({
+      onError: (level, message) => {
+        if (level !== "error" && level !== "fatalError") return;
+        if (/entity not found/i.test(message)) return;
+        errors.push(message);
+      }
+    }).parseFromString(body, "text/xml");
+    const root = doc.documentElement;
+    if (errors.length === 0 && root !== null) parsed = { root, body, shift, starts: lineStarts(body) };
+  } catch {
+    parsed = null;
+  }
+  cache.set(input, parsed);
+  return parsed;
+}
+function nameOf(el) {
+  return (el.localName ?? el.nodeName).toLowerCase();
+}
+function childrenOf(el, name) {
+  const out = [];
+  for (let i = 0; i < el.children.length; i++) {
+    const child = el.children.item(i);
+    if (child !== null && (name === void 0 || nameOf(child) === name)) out.push(child);
+  }
+  return out;
+}
+function descendantsOf(el, name) {
+  const out = [];
+  const walk = (parent) => {
+    for (const child of childrenOf(parent)) {
+      if (nameOf(child) === name) out.push(child);
+      walk(child);
+    }
+  };
+  walk(el);
+  return out;
+}
+function textOfElement(el) {
+  return collapse(el.textContent ?? "");
+}
+function lineOfElement(el) {
+  return el.lineNumber ?? 1;
+}
+function skipOpaque(body, from) {
+  const opaque = [
+    ["<!--", "-->"],
+    ["<![CDATA[", "]]>"],
+    ["<?", "?>"],
+    ["<!", ">"]
+  ];
+  for (const [open, close] of opaque) {
+    if (body.startsWith(open, from)) {
+      const end = body.indexOf(close, from + open.length);
+      return end === -1 ? body.length : end + close.length;
+    }
+  }
+  return void 0;
+}
+function tagEnd(body, from) {
+  let quote;
+  for (let i = from + 1; i < body.length; i++) {
+    const ch = body[i];
+    if (quote !== void 0) {
+      if (ch === quote) quote = void 0;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return { end: i + 1, selfClosing: body[i - 1] === "/" };
+    }
+  }
+  return void 0;
+}
+function namedAt(body, at, name) {
+  if (!body.startsWith(name, at)) return false;
+  const after = body[at + name.length];
+  return after === void 0 || /[\s/>]/.test(after);
+}
+function spanOfElement(xml, el) {
+  const lineStart = xml.starts[(el.lineNumber ?? 1) - 1];
+  if (lineStart === void 0) return void 0;
+  const start = lineStart + (el.columnNumber ?? 1) - 1;
+  const { body } = xml;
+  if (body[start] !== "<") return void 0;
+  const name = el.nodeName;
+  const open = tagEnd(body, start);
+  if (open === void 0) return void 0;
+  if (open.selfClosing) return { start: start + xml.shift, end: open.end + xml.shift };
+  let depth = 1;
+  let i = open.end;
+  while (i < body.length) {
+    const lt = body.indexOf("<", i);
+    if (lt === -1) return void 0;
+    const skipTo = skipOpaque(body, lt);
+    if (skipTo !== void 0) {
+      i = skipTo;
+      continue;
+    }
+    const tag = tagEnd(body, lt);
+    if (tag === void 0) return void 0;
+    if (body[lt + 1] === "/" && namedAt(body, lt + 2, name)) {
+      depth -= 1;
+      if (depth === 0) return { start: start + xml.shift, end: tag.end + xml.shift };
+    } else if (namedAt(body, lt + 1, name) && !tag.selfClosing) {
+      depth += 1;
+    }
+    i = tag.end;
+  }
+  return void 0;
+}
+
+// src/term/core/readers/dita.ts
+function definitionOf(glossdef) {
+  const paragraphs = childrenOf(glossdef, "p");
+  if (paragraphs.length === 0) return textOfElement(glossdef);
+  return paragraphs.map(textOfElement).filter((text) => text !== "").join("\n\n");
+}
+function readEntry(input, xml, entry, construct, label) {
+  const raw = {};
+  const lines = {};
+  const [glossterm] = childrenOf(entry, "glossterm");
+  if (glossterm !== void 0) {
+    raw.label = textOfElement(glossterm);
+    lines.label = lineOfElement(glossterm);
+  }
+  const [glossdef] = childrenOf(entry, "glossdef");
+  if (glossdef !== void 0) {
+    raw.definition = definitionOf(glossdef);
+    lines.definition = lineOfElement(glossdef);
+  }
+  const alts = [];
+  for (const body of childrenOf(entry, "glossbody")) {
+    const [usage] = childrenOf(body, "glossusage");
+    if (usage !== void 0 && raw["scope-note"] === void 0) {
+      raw["scope-note"] = textOfElement(usage);
+      lines["scope-note"] = lineOfElement(usage);
+    }
+    for (const alt of childrenOf(body, "glossalt")) {
+      for (const form of childrenOf(alt)) {
+        const name = nameOf(form);
+        if (name !== "glosssynonym" && name !== "glossacronym") continue;
+        alts.push(textOfElement(form));
+        lines["alt-labels"] ??= lineOfElement(form);
+      }
+    }
+  }
+  raw["alt-labels"] = alts;
+  const line = lineOfElement(entry);
+  const record = recordOf(raw);
+  if (record === void 0) return skipped(input, line, label);
+  const span = spanOfElement(xml, entry);
+  return termOf(input, {
+    record,
+    constructId: entry.getAttribute("id"),
+    construct,
+    line,
+    lines,
+    ...span === void 0 ? {} : { span }
+  });
+}
+function collect(input, xml, entries, construct, label) {
+  const result = nothing();
+  for (const entry of entries) {
+    const read8 = readEntry(input, xml, entry, construct, label);
+    if (typeof read8 === "string") result.notices.push(read8);
+    else result.terms.push(read8);
+  }
+  return result;
+}
+var GLOSSENTRY_LABEL = "DITA glossentry";
+var GLOSSGROUP_LABEL = "DITA glossgroup";
+function readGlossentry(input) {
+  const xml = parseXml(input);
+  if (xml === null || nameOf(xml.root) !== "glossentry") return nothing();
+  return collect(input, xml, [xml.root], "dita-glossentry", GLOSSENTRY_LABEL);
+}
+function readGlossgroup(input) {
+  const xml = parseXml(input);
+  if (xml === null || nameOf(xml.root) !== "glossgroup") return nothing();
+  return collect(input, xml, descendantsOf(xml.root, "glossentry"), "dita-glossgroup", GLOSSGROUP_LABEL);
+}
+var ditaGlossentryReader = {
+  construct: "dita-glossentry",
+  label: GLOSSENTRY_LABEL,
+  formats: ["xml"],
+  read: readGlossentry,
+  // The glossentry is the file's root, so the file's `xml:lang` sits on it and
+  // is written again when the entry is.
+  apply: (input, terms) => applyEntries(input, readGlossentry, terms, {
+    holds: DITA_HOLDS,
+    id: true,
+    serialize: (term, file) => ditaEntry(term, textOf(file.metadata["xml:lang"]) === void 0 ? void 0 : term.language)
+  })
+};
+var ditaGlossgroupReader = {
+  construct: "dita-glossgroup",
+  label: GLOSSGROUP_LABEL,
+  formats: ["xml"],
+  read: readGlossgroup,
+  apply: (input, terms) => applyEntries(input, readGlossgroup, terms, { holds: DITA_HOLDS, id: true, serialize: (term) => ditaEntry(term) })
+};
+
+// src/term/core/readers/docbook.ts
+var LABEL = "DocBook glossary";
+function referenceOf(el) {
+  return textOf(textOfElement(el)) ?? textOf(el.getAttribute("otherterm"));
+}
+function definitionOf2(glossdef) {
+  const children = childrenOf(glossdef);
+  const blocks = children.filter((child) => nameOf(child) !== "glossseealso");
+  if (blocks.length === 0) return children.length === 0 ? textOfElement(glossdef) : "";
+  return blocks.map(textOfElement).filter((text) => text !== "").join("\n\n");
+}
+function read(input) {
+  const xml = parseXml(input);
+  if (xml === null) return nothing();
+  const glossaries = nameOf(xml.root) === "glossary" ? [xml.root] : descendantsOf(xml.root, "glossary");
+  if (glossaries.length === 0) return nothing();
+  const seen = /* @__PURE__ */ new Set();
+  const result = nothing();
+  for (const glossary of glossaries) {
+    for (const entry of descendantsOf(glossary, "glossentry")) {
+      if (seen.has(entry)) continue;
+      seen.add(entry);
+      const raw = {};
+      const lines = {};
+      const alts = [];
+      const definitions = [];
+      const related = [];
+      for (const child of childrenOf(entry)) {
+        const name = nameOf(child);
+        if (name === "glossterm" && raw.label === void 0) {
+          raw.label = textOfElement(child);
+          lines.label = lineOfElement(child);
+        } else if (name === "glossterm" || name === "acronym") {
+          alts.push(textOfElement(child));
+          lines["alt-labels"] ??= lineOfElement(child);
+        } else if (name === "glossdef") {
+          definitions.push(definitionOf2(child));
+          lines.definition ??= lineOfElement(child);
+          for (const seeAlso of childrenOf(child, "glossseealso")) {
+            const target = referenceOf(seeAlso);
+            if (target !== void 0) related.push(target);
+            lines["related-terms"] ??= lineOfElement(seeAlso);
+          }
+        } else if (name === "glosssee" && raw.see === void 0) {
+          raw.see = referenceOf(child);
+          lines.see = lineOfElement(child);
+        }
+      }
+      raw["alt-labels"] = alts;
+      raw.definition = definitions.filter((text) => text !== "").join("\n\n");
+      raw["related-terms"] = related;
+      const line = lineOfElement(entry);
+      const record = recordOf(raw);
+      if (record === void 0) {
+        result.notices.push(skipped(input, line, LABEL));
+        continue;
+      }
+      const span = spanOfElement(xml, entry);
+      result.terms.push(
+        termOf(input, {
+          record,
+          constructId: entry.getAttribute("xml:id"),
+          construct: "docbook-glossary",
+          line,
+          lines,
+          ...span === void 0 ? {} : { span }
+        })
+      );
+    }
+  }
+  return result;
+}
+var docbookGlossaryReader = {
+  construct: "docbook-glossary",
+  label: LABEL,
+  formats: ["xml"],
+  read,
+  apply: (input, terms) => applyEntries(input, read, terms, { holds: DOCBOOK_HOLDS, id: true, serialize: docbookEntry })
+};
+
+// src/term/core/readers/html.ts
+import { parse } from "parse5";
+var cache2 = /* @__PURE__ */ new WeakMap();
+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;
+}
+function isElement(node) {
+  return "tagName" in node;
+}
+function childElements(node) {
+  return node.childNodes.filter(isElement);
+}
+function elementsNamed(node, name) {
+  const out = [];
+  const walk = (parent) => {
+    for (const child of childElements(parent)) {
+      if (child.tagName === name) out.push(child);
+      walk(child);
+    }
+  };
+  walk(node);
+  return out;
+}
+function rawText(node) {
+  let text = "";
+  for (const child of node.childNodes) {
+    if (child.nodeName === "#text" && "value" in child) text += child.value;
+    else if (isElement(child)) text += rawText(child);
+  }
+  return text;
+}
+function textOfNode(node) {
+  return collapse(rawText(node));
+}
+function attr(el, name) {
+  return el.attrs.find((a) => a.name === name)?.value;
+}
+function lineOf(el) {
+  return el.sourceCodeLocation?.startLine ?? 1;
+}
+function spanOf(parsed, 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 };
+}
+function definitionOf3(dd) {
+  const paragraphs = childElements(dd).filter((child) => child.tagName === "p");
+  if (paragraphs.length === 0) return textOfNode(dd);
+  return paragraphs.map(textOfNode).filter((text) => text !== "").join("\n\n");
+}
+function listItems(dl) {
+  return childElements(dl).flatMap((child) => child.tagName === "div" ? childElements(child) : [child]);
+}
+var DL_LABEL = "dl";
+function readDl(input) {
+  if (!declares(input, "term-set")) return nothing();
+  const parsed = parseHtml(input);
+  const result = nothing();
+  for (const dl of elementsNamed(parsed.root, "dl")) {
+    const items = listItems(dl).filter((item2) => item2.tagName === "dt" || item2.tagName === "dd");
+    let i = 0;
+    while (i < items.length) {
+      const dts = [];
+      const dds = [];
+      for (let item2 = items[i]; item2?.tagName === "dt"; item2 = items[++i]) dts.push(item2);
+      for (let item2 = items[i]; item2?.tagName === "dd"; item2 = items[++i]) dds.push(item2);
+      const first = dts[0] ?? dds[0];
+      const last = dds[dds.length - 1] ?? dts[dts.length - 1];
+      if (first === void 0 || last === void 0) break;
+      const named = dts.filter((dt) => textOfNode(dt) !== "");
+      const [labelDt, ...altDts] = named;
+      const [dd] = dds;
+      const raw = {
+        label: labelDt === void 0 ? void 0 : textOfNode(labelDt),
+        "alt-labels": altDts.map(textOfNode),
+        definition: dd === void 0 ? void 0 : definitionOf3(dd)
+      };
+      const lines = {
+        label: labelDt === void 0 ? void 0 : lineOf(labelDt),
+        "alt-labels": altDts[0] === void 0 ? void 0 : lineOf(altDts[0]),
+        definition: dd === void 0 ? void 0 : lineOf(dd)
+      };
+      const line = lineOf(first);
+      const record = recordOf(raw);
+      if (record === void 0) {
+        result.notices.push(skipped(input, line, DL_LABEL));
+        continue;
+      }
+      const span = spanOf(parsed, first, last);
+      const constructId = dts.map((dt) => textOf(attr(dt, "id"))).find((id) => id !== void 0);
+      result.terms.push(
+        termOf(input, {
+          record,
+          constructId,
+          construct: "html-dl",
+          line,
+          lines,
+          ...span === void 0 ? {} : { span }
+        })
+      );
+    }
+  }
+  return result;
+}
+var DFN_LABEL = "dfn";
+function insideDt(el) {
+  let parent = el.parentNode;
+  while (parent !== null && "tagName" in parent) {
+    if (parent.tagName === "dt") return true;
+    parent = parent.parentNode;
+  }
+  return false;
+}
+function dfnFields(dfn) {
+  const title = textOf(attr(dfn, "title"));
+  if (title !== void 0) return { label: title };
+  const content = dfn.childNodes.filter(
+    (child) => child.nodeName === "#text" && "value" in child ? child.value.trim() !== "" : isElement(child)
+  );
+  const [only] = content;
+  if (content.length === 1 && only !== void 0 && isElement(only) && only.tagName === "abbr") {
+    const abbrTitle = textOf(attr(only, "title"));
+    if (abbrTitle !== void 0) return { label: abbrTitle, alt: textOfNode(only) };
+  }
+  return { label: textOfNode(dfn) };
+}
+function readDfn(input) {
+  if (!declares(input, "term-set")) return nothing();
+  const parsed = parseHtml(input);
+  const result = nothing();
+  for (const dfn of elementsNamed(parsed.root, "dfn")) {
+    if (insideDt(dfn)) continue;
+    const { label, alt } = dfnFields(dfn);
+    const line = lineOf(dfn);
+    const record = recordOf({ label, "alt-labels": alt });
+    if (record === void 0) {
+      result.notices.push(skipped(input, line, DFN_LABEL));
+      continue;
+    }
+    const span = spanOf(parsed, dfn, dfn);
+    const term = termOf(input, {
+      record,
+      constructId: attr(dfn, "id"),
+      construct: "html-dfn",
+      line,
+      lines: { label: line, "alt-labels": line },
+      ...span === void 0 ? {} : { span }
+    });
+    result.terms.push(term);
+  }
+  return result;
+}
+var htmlDlReader = {
+  construct: "html-dl",
+  label: DL_LABEL,
+  formats: ["html"],
+  read: readDl,
+  apply: (input, terms) => applyEntries(input, readDl, terms, { holds: LIST_HOLDS, id: true, serialize: htmlDlEntry })
+};
+var htmlDfnReader = {
+  construct: "html-dfn",
+  label: DFN_LABEL,
+  formats: ["html"],
+  read: readDfn
+};
+
+// src/term/core/readers/manifest.ts
+import { isMap, isNode, isScalar, isSeq, LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
+var LABEL2 = "manifest";
+var FIELDS = new Set(TERM_FIELDS);
+function isField(key) {
+  return FIELDS.has(key);
+}
+function read2(input) {
+  if ((input.path ?? input.file).toLowerCase().endsWith(".json")) {
+    try {
+      JSON.parse(input.content);
+    } catch (error) {
+      throw new TermError(`${input.file}: could not be parsed as JSON: ${errorMessage(error)}`);
+    }
+  }
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(input.content, { lineCounter, prettyErrors: false });
+  const [firstError] = doc.errors;
+  if (firstError !== void 0) {
+    throw new TermError(`${input.file}: could not be parsed as YAML: ${firstError.message}`);
+  }
+  const lineOf2 = (node) => {
+    const range = node?.range;
+    return range === void 0 || range === null ? void 0 : lineCounter.linePos(range[0]).line;
+  };
+  const root = doc.contents;
+  if (root === null) return { terms: [], notices: [] };
+  if (!isMap(root)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const terms = [];
+  const notices = [];
+  for (const pair of root.items) {
+    const keyNode = isScalar(pair.key) ? pair.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;
+    if (!isMap(value)) {
+      throw new TermError(`${input.file}:${line}: entry "${id}" is not a mapping of fields.`);
+    }
+    const raw = {};
+    const lines = {};
+    for (const field of value.items) {
+      const fieldKey = isScalar(field.key) ? field.key : void 0;
+      const name = fieldKey?.value;
+      if (typeof name !== "string" || !isField(name)) continue;
+      const fieldValue = field.value;
+      raw[name] = isNode(fieldValue) ? fieldValue.toJSON() : fieldValue;
+      lines[name] = lineOf2(fieldKey);
+    }
+    const record = recordOf(raw);
+    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));
+    }
+    terms.push(termOf(input, { record, recordId: id, construct: "manifest", line, lines }));
+  }
+  return { terms, notices };
+}
+function entryOf(record) {
+  const entry = {};
+  for (const field of TERM_FIELDS) {
+    const value = record[field];
+    if (value !== void 0) entry[field] = value;
+  }
+  return entry;
+}
+function currentRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  const raw = {};
+  for (const field of TERM_FIELDS) raw[field] = value[field];
+  return recordOf(raw) ?? {};
+}
+function changedFields(current, record) {
+  return TERM_FIELDS.filter((field) => JSON.stringify(current[field]) !== JSON.stringify(record[field]));
+}
+function applyJson(input, terms) {
+  let data;
+  try {
+    data = JSON.parse(input.content);
+  } catch (error) {
+    throw new TermError(`${input.file}: could not be parsed as JSON: ${errorMessage(error)}`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const root = data;
+  let changed = false;
+  for (const term of terms) {
+    const existing = root[term.id];
+    if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+      if (existing !== void 0) {
+        throw new TermError(`${input.file}: entry "${term.id}" is not a mapping of fields.`);
+      }
+      root[term.id] = entryOf(term.record);
+      changed = true;
+      continue;
+    }
+    const entry = existing;
+    const fields = changedFields(currentRecord(entry), term.record);
+    if (fields.length === 0) continue;
+    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];
+    }
+    for (const field of fields) {
+      if (term.record[field] !== void 0 && !(field in next)) next[field] = term.record[field];
+    }
+    root[term.id] = next;
+    changed = true;
+  }
+  if (!changed) return input.content;
+  const text = `${JSON.stringify(root, null, 2)}
+`;
+  return input.content.includes("\r\n") ? text.replaceAll("\n", "\r\n") : text;
+}
+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];
+    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];
+    if (value === void 0) {
+      entry.delete(field);
+    } else if (Array.isArray(value)) {
+      const previous = entry.get(field, true);
+      const node = doc.createNode(value);
+      node.flow = isSeq(previous) && previous.flow === true;
+      entry.set(field, node);
+    } else {
+      entry.set(field, value);
+    }
+  }
+  return fields.length > 0;
+}
+function applyYaml(input, terms) {
+  const { content } = input;
+  const doc = parseDocument(content, { prettyErrors: false });
+  const [firstError] = doc.errors;
+  if (firstError !== void 0) {
+    throw new TermError(`${input.file}: could not be parsed as YAML: ${firstError.message}`);
+  }
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  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)]));
+    return stringifyYaml(entries, { lineWidth: 0 }).replaceAll("\n", eol);
+  }
+  if (!isMap(root)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const wholeFile = root.flow === true;
+  const before = entryRanges(root);
+  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)));
+      added.push(term.id);
+      continue;
+    }
+    if (!isMap(pair.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 (changed.length === 0 && added.length === 0) return content;
+  const text = doc.toString({ lineWidth: 0 });
+  if (wholeFile) return text.replaceAll("\n", eol);
+  const written = parseDocument(text).contents;
+  const after = isMap(written) ? entryRanges(written) : /* @__PURE__ */ new Map();
+  const entryText = (id) => {
+    const range = after.get(id);
+    if (range === void 0) throw new TermError(`${input.file}: could not write entry "${id}".`);
+    return text.slice(range.start, range.end).replaceAll("\n", eol);
+  };
+  let next = content;
+  const edits = changed.map((id) => ({ id, range: before.get(id) })).sort((a, b) => (b.range?.start ?? 0) - (a.range?.start ?? 0));
+  for (const { id, range } of edits) {
+    if (range === void 0) throw new TermError(`${input.file}: could not write entry "${id}".`);
+    next = next.slice(0, range.start) + entryText(id) + next.slice(range.end);
+  }
+  if (added.length > 0) {
+    if (next !== "" && !next.endsWith("\n")) next += eol;
+    next += added.map((id) => `${entryText(id)}${eol}`).join("");
+  }
+  return next;
+}
+function isJson(input) {
+  return (input.path ?? input.file).toLowerCase().endsWith(".json");
+}
+var manifestReader = {
+  construct: "manifest",
+  label: LABEL2,
+  formats: ["manifest"],
+  read: read2,
+  apply: (input, terms) => isJson(input) ? applyJson(input, terms) : applyYaml(input, terms)
+};
+
+// src/term/core/readers/page.ts
+var LABEL3 = "page";
+function read3(input) {
+  if (!declares(input, "term")) return nothing();
+  const raw = {};
+  const lines = {};
+  for (const field of TERM_FIELDS) {
+    raw[field] = input.metadata[field];
+    lines[field] = input.lineFor(`/${field}`);
+  }
+  const record = recordOf(raw);
+  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)
+    )
+  };
+}
+function apply(input, terms) {
+  const [term] = terms;
+  if (term === void 0) return input.content;
+  const [current] = read3(input).terms;
+  if (current === void 0) {
+    throw new TermError(`${input.file}: is not a term page any more. Read the file again before writing it.`);
+  }
+  const patch = {};
+  const deletions = [];
+  for (const field of TERM_FIELDS) {
+    if (sameFields(current.record, term.record, [field])) continue;
+    const value = term.record[field];
+    if (value === void 0) deletions.push(field);
+    else patch[field] = value;
+  }
+  if (Object.keys(patch).length === 0 && deletions.length === 0) return input.content;
+  const extractor = extractorByName(input.format);
+  if (extractor?.apply === void 0) {
+    throw new TermError(`${input.file}: manni cannot write ${input.format} metadata.`);
+  }
+  const filePath = input.path ?? input.file;
+  let next;
+  try {
+    next = extractor.apply(input.content, patch, { deletions, filePath });
+  } catch (error) {
+    throw new TermError(`${input.file}: ${errorMessage(error)}`);
+  }
+  const written = extractor.extract(next, filePath).data;
+  for (const field of deletions) {
+    if (written[field] !== void 0) {
+      throw new TermError(`${input.file}: could not remove ${field} from its ${input.format} metadata. Remove it by hand.`);
+    }
+  }
+  return next;
+}
+var pageReader = {
+  construct: "page",
+  label: LABEL3,
+  formats: ["markdown", "mdx", "asciidoc", "rst", "html", "xml"],
+  read: read3,
+  apply
+};
+
+// src/term/core/readers/structured.ts
+var STRUCTURED_READERS = [
+  pageReader,
+  manifestReader,
+  ditaGlossentryReader,
+  ditaGlossgroupReader,
+  docbookGlossaryReader,
+  htmlDlReader,
+  htmlDfnReader
+];
+
+// src/term/core/readers/body.ts
+function textStart(line) {
+  return line.start + (line.text.length - line.text.trimStart().length);
+}
+function isBlank(line) {
+  return line.text.trim() === "";
+}
+function nextNonBlank(lines, from) {
+  let k = from;
+  for (let line = lines[k]; line !== void 0 && !line.code && isBlank(line); line = lines[k]) k++;
+  return k;
+}
+function bodyLines(input) {
+  const { content } = input;
+  const bodyStart = locateFrontmatter(content)?.closeEnd ?? 0;
+  const body = content.slice(bodyStart);
+  const code = codeRegions(body, input.format, { spans: false });
+  let line = 1;
+  for (let i = 0; i < bodyStart; i++) {
+    if (content.charCodeAt(i) === 10) line++;
+  }
+  const out = [];
+  let pos = bodyStart;
+  while (pos < content.length) {
+    const nl = content.indexOf("\n", pos);
+    const stop = nl === -1 ? content.length : nl;
+    const end = stop > pos && content.charCodeAt(stop - 1) === 13 ? stop - 1 : stop;
+    out.push({
+      text: content.slice(pos, end),
+      start: pos,
+      end,
+      line,
+      code: codeEndAt(code, pos - bodyStart) !== void 0
+    });
+    line++;
+    pos = stop + 1;
+  }
+  return out;
+}
+function definitionText(paragraphs) {
+  const text = paragraphs.map(
+    (lines) => lines.map((l) => l.trim()).filter((l) => l !== "").join(" ")
+  ).filter((p) => p !== "").join("\n\n");
+  return text === "" ? void 0 : text;
+}
+function termOf2(input, construct, entry) {
+  const [first, ...rest] = entry.labels;
+  const label = first?.text.trim() ?? "";
+  const record = { label };
+  const fieldLines = { label: first?.line ?? entry.definitionLine };
+  const alts = rest.map((l) => l.text.trim()).filter((t) => t !== "");
+  const [firstAlt] = rest;
+  if (alts.length > 0 && firstAlt !== void 0) {
+    record["alt-labels"] = alts;
+    fieldLines["alt-labels"] = firstAlt.line;
+  }
+  record.definition = entry.definition;
+  fieldLines.definition = entry.definitionLine;
+  const language = input.metadata["language"];
+  return {
+    id: slugOf(label),
+    record,
+    ...typeof language === "string" && language.trim() !== "" ? { language: language.trim() } : {},
+    location: {
+      file: input.file,
+      ...input.path === void 0 ? {} : { path: input.path },
+      construct,
+      line: first?.line ?? entry.definitionLine,
+      fieldLines,
+      span: { start: entry.start, end: entry.end }
+    }
+  };
+}
+function skippedNotice(input, line, label, missing) {
+  return `${input.file}:${String(line)}: skipped a ${label} entry with no ${missing}.`;
+}
+
+// src/term/core/readers/asciidoc-glossary.ts
+var LABEL4 = "[glossary] list";
+var ATTRIBUTE = /^\[glossary\][ \t]*$/;
+var ITEM = /^[ \t]*(.*?[^:\s])::(?:[ \t]+(.*))?$/;
+var BLOCK_TITLE = /^\.[^.\s]/;
+var LIST_END = /^(?:=+[ \t]|\[.*\][ \t]*$|(?:-{4,}|={4,}|\*{4,}|\.{4,}|_{4,}|\+{4,}|\|===)[ \t]*$)/;
+function item(line) {
+  const match = ITEM.exec(line.text);
+  const term = match?.[1];
+  if (match === null || term === void 0) return void 0;
+  const text = match[2]?.trim();
+  return { term, text: text === "" ? void 0 : text };
+}
+function read4(input) {
+  const terms = [];
+  const notices = [];
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    i++;
+    if (line === void 0 || line.code || !ATTRIBUTE.test(line.text)) continue;
+    let start = i;
+    for (let l = lines[start]; l !== void 0 && !l.code && (isBlank(l) || BLOCK_TITLE.test(l.text)); l = lines[start]) {
+      start++;
+    }
+    const first = lines[start];
+    if (first === void 0 || first.code || item(first) === void 0) continue;
+    i = readList(input, lines, start, terms, notices);
+  }
+  return { terms, notices };
+}
+function readList(input, lines, at, terms, notices) {
+  let pending = [];
+  let open;
+  const close = () => {
+    if (open !== void 0) {
+      const text = definitionText(open.paragraphs);
+      const [firstLabel] = open.labels;
+      if (text !== void 0 && firstLabel !== void 0) {
+        terms.push(
+          termOf2(input, "asciidoc-glossary", {
+            labels: open.labels.map((l) => ({ text: itemTerm(l), line: l.line })),
+            definition: text,
+            definitionLine: open.definitionLine,
+            start: textStart(firstLabel),
+            end: open.last.end
+          })
+        );
+      } else if (firstLabel !== void 0) {
+        notices.push(skippedNotice(input, firstLabel.line, LABEL4, "definition"));
+      }
+      open = void 0;
+    }
+    const [firstPending] = pending;
+    if (firstPending !== void 0) {
+      notices.push(skippedNotice(input, firstPending.line, LABEL4, "definition"));
+      pending = [];
+    }
+  };
+  let i = at;
+  for (; ; ) {
+    const line = lines[i];
+    if (line === void 0 || line.code) break;
+    if (isBlank(line)) {
+      close();
+      const k = nextNonBlank(lines, i);
+      const next = lines[k];
+      if (next === void 0 || next.code || item(next) === void 0) break;
+      i = k;
+      continue;
+    }
+    const entry = item(line);
+    if (entry !== void 0) {
+      if (open !== void 0) close();
+      pending.push(line);
+      if (entry.text !== void 0) {
+        open = { labels: pending, definitionLine: line.line, paragraphs: [[entry.text]], last: line };
+        pending = [];
+      }
+      i++;
+      continue;
+    }
+    if (line.text.trim() === "+" && open !== void 0) {
+      open.paragraphs.push([]);
+      i++;
+      continue;
+    }
+    if (LIST_END.test(line.text) || BLOCK_TITLE.test(line.text)) break;
+    if (open !== void 0) {
+      open.paragraphs.at(-1)?.push(line.text);
+      open.last = line;
+    } else if (pending.length > 0) {
+      open = { labels: pending, definitionLine: line.line, paragraphs: [[line.text]], last: line };
+      pending = [];
+    } else {
+      break;
+    }
+    i++;
+  }
+  close();
+  return i;
+}
+function itemTerm(line) {
+  return item(line)?.term ?? line.text;
+}
+var asciidocGlossaryReader = {
+  construct: "asciidoc-glossary",
+  label: LABEL4,
+  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 DEFINITION = /^:(?:[ \t]+(.*))?$/;
+var INDENTED = /^(?: {4}|\t)/;
+var HEADING = /^#{1,6}(?:[ \t]|$)/;
+function definitionStart(line) {
+  if (line === void 0 || line.code) return void 0;
+  const match = DEFINITION.exec(line.text);
+  return match === null ? void 0 : match[1] ?? "";
+}
+function read5(input) {
+  const terms = [];
+  const notices = [];
+  if (input.metadata["type"] !== "term-set") return { terms, notices };
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const first = lines[i];
+    if (first === void 0) break;
+    if (first.code || isBlank(first)) {
+      i++;
+      continue;
+    }
+    const labels = [];
+    let j = i;
+    for (; ; ) {
+      const line = lines[j];
+      if (line === void 0 || line.code || isBlank(line) || definitionStart(line) !== void 0) break;
+      labels.push(line);
+      j++;
+    }
+    const opener = definitionStart(lines[j]);
+    if (opener === void 0) {
+      i = j === i ? i + 1 : j;
+      continue;
+    }
+    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"));
+      i = readDefinitions(lines, j, []);
+      continue;
+    }
+    const definitions = [];
+    i = readDefinitions(lines, j, definitions);
+    const firstLabel = labels[0];
+    const [kept] = definitions;
+    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"));
+      continue;
+    }
+    for (const extra of definitions.slice(1)) {
+      notices.push(
+        `${input.file}:${String(extra.line)}: kept the first of ${String(definitions.length)} definitions for "${firstLabel.text.trim()}".`
+      );
+    }
+    const last = lastContentLine(lines, i);
+    terms.push(
+      termOf2(input, "markdown-deflist", {
+        labels: labels.map((l) => ({ text: l.text, line: l.line })),
+        definition: text,
+        definitionLine: kept.line,
+        start: textStart(firstLabel),
+        end: last?.end ?? firstLabel.end
+      })
+    );
+  }
+  return { terms, notices };
+}
+function lastContentLine(lines, stop) {
+  for (let k = stop - 1; k >= 0; k--) {
+    const line = lines[k];
+    if (line !== void 0 && !isBlank(line)) return line;
+  }
+  return void 0;
+}
+function readDefinitions(lines, at, out) {
+  let i = at;
+  for (; ; ) {
+    const opener = lines[i];
+    const text = definitionStart(opener);
+    if (opener === void 0 || text === void 0) return i;
+    const definition = { line: opener.line, paragraphs: [[text]] };
+    out.push(definition);
+    i++;
+    for (; ; ) {
+      const line = lines[i];
+      if (line === void 0 || line.code) return i;
+      if (definitionStart(line) !== void 0) break;
+      if (!isBlank(line)) {
+        definition.paragraphs.at(-1)?.push(line.text.replace(INDENTED, ""));
+        i++;
+        continue;
+      }
+      const k = nextNonBlank(lines, i);
+      const next = lines[k];
+      if (next === void 0 || next.code) return i;
+      if (definitionStart(next) !== void 0) {
+        i = k;
+        break;
+      }
+      if (!INDENTED.test(next.text)) return i;
+      definition.paragraphs.push([]);
+      i = k;
+    }
+  }
+}
+var markdownDeflistReader = {
+  construct: "markdown-deflist",
+  label: LABEL5,
+  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 DIRECTIVE = /^[ \t]*\.\.[ \t]+glossary::[ \t]*$/;
+var CODE_DIRECTIVE = /^[ \t]*\.\.[ \t]+(?:code-block|code|sourcecode)::/;
+var EXPLICIT_MARKUP = /^[ \t]*\.\.(?:[ \t]|$)/;
+var OPTION = /^[ \t]*:[^:\s][^:]*:(?:[ \t].*)?$/;
+var CLASSIFIER = /[ \t]+:[ \t]+/;
+function indentOf(text) {
+  let width = 0;
+  for (const ch of text) {
+    if (ch === " ") width++;
+    else if (ch === "	") width += 8 - width % 8;
+    else break;
+  }
+  return width;
+}
+function opensLiteral(line) {
+  if (CODE_DIRECTIVE.test(line.text)) return true;
+  return !EXPLICIT_MARKUP.test(line.text) && line.text.trimEnd().endsWith("::");
+}
+function read6(input) {
+  const terms = [];
+  const notices = [];
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === void 0) break;
+    if (isBlank(line)) {
+      i++;
+      continue;
+    }
+    if (DIRECTIVE.test(line.text)) {
+      i = readGlossary(input, lines, i, terms, notices);
+      continue;
+    }
+    i = opensLiteral(line) ? blockEnd(lines, i + 1, indentOf(line.text)) : i + 1;
+  }
+  return { terms, notices };
+}
+function blockEnd(lines, from, indent) {
+  let k = from;
+  for (let l = lines[k]; l !== void 0 && (isBlank(l) || indentOf(l.text) > indent); l = lines[k]) k++;
+  return k;
+}
+function readGlossary(input, lines, at, terms, notices) {
+  const directive = lines[at];
+  if (directive === void 0) return at + 1;
+  const end = blockEnd(lines, at + 1, indentOf(directive.text));
+  let i = at + 1;
+  for (let l = lines[i]; i < end && l !== void 0 && !isBlank(l) && OPTION.test(l.text); l = lines[i]) i++;
+  let base;
+  let labels = [];
+  let definition;
+  let orphan = false;
+  const close = () => {
+    const [first] = labels;
+    if (first !== void 0) {
+      const text = definition === void 0 ? void 0 : definitionText(definition.paragraphs);
+      if (definition !== void 0 && text !== void 0) {
+        terms.push(
+          termOf2(input, "rst-glossary", {
+            labels: labels.map((l) => ({ text: termText(l), line: l.line })),
+            definition: text,
+            definitionLine: definition.line,
+            start: textStart(first),
+            end: definition.last.end
+          })
+        );
+      } else {
+        notices.push(skippedNotice(input, first.line, LABEL6, "definition"));
+      }
+    }
+    labels = [];
+    definition = void 0;
+  };
+  let blank = false;
+  for (; i < end; i++) {
+    const line = lines[i];
+    if (line === void 0) break;
+    if (isBlank(line)) {
+      if (definition !== void 0) definition.gap = true;
+      blank = true;
+      continue;
+    }
+    const indent = indentOf(line.text);
+    base ??= indent;
+    if (indent <= base) {
+      if (definition !== void 0 || blank) close();
+      orphan = false;
+      blank = false;
+      labels.push(line);
+      continue;
+    }
+    blank = false;
+    if (definition !== void 0) {
+      if (definition.gap) {
+        definition.paragraphs.push([]);
+        definition.gap = false;
+      }
+      definition.paragraphs.at(-1)?.push(line.text);
+      definition.last = line;
+    } 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"));
+      orphan = true;
+    }
+  }
+  close();
+  return end;
+}
+function termText(line) {
+  const text = line.text.trim();
+  const match = CLASSIFIER.exec(text);
+  return match === null ? text : text.slice(0, match.index);
+}
+var rstGlossaryReader = {
+  construct: "rst-glossary",
+  label: LABEL6,
+  formats: ["rst"],
+  read: read6,
+  apply: (input, terms) => applyEntries(input, read6, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => rstEntry(term.record) })
+};
+
+// src/term/core/readers/text.ts
+var TEXT_READERS = [
+  markdownDeflistReader,
+  asciidocGlossaryReader,
+  rstGlossaryReader
+];
+
+// src/term/core/readers/index.ts
+var TERM_READERS = [...STRUCTURED_READERS, ...TEXT_READERS];
+function readersForFormat(format, readers = TERM_READERS) {
+  return readers.filter((reader) => reader.formats.includes(format));
+}
+function readerForConstruct(construct, readers = TERM_READERS) {
+  return readers.find((reader) => reader.construct === construct);
+}
+
+// src/term/core/load-set.ts
+var MANIFEST_FORMAT = "manifest";
+var MANIFEST_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
+function manifestInput(content, file, path) {
+  return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
+}
+function labelsOf2(value) {
+  if (typeof value === "string") return value.trim() === "" ? [] : [value];
+  if (Array.isArray(value)) {
+    return value.filter((item2) => typeof item2 === "string" && item2.trim() !== "");
+  }
+  return [];
+}
+function referencesOf(input) {
+  const references = [];
+  const add = (value, pointer) => {
+    for (const label of labelsOf2(value)) {
+      const line = input.lineFor(pointer);
+      references.push({ file: input.file, label, ...line === void 0 ? {} : { line } });
+    }
+  };
+  for (const path of CONCEPT_FIELDS) add(valueAt(input.metadata, path), fieldPointer(path));
+  return references;
+}
+function read7(input, readers, set) {
+  for (const reader of readersForFormat(input.format, readers)) {
+    const result = reader.read(input);
+    set.terms.push(...result.terms);
+    set.notices.push(...result.notices);
+  }
+}
+function extractInput(content, file, path, format) {
+  const extractor = extractorByName(format);
+  if (extractor === void 0) {
+    throw new TermError(`${file}: no reader for format "${format}".`);
+  }
+  let extracted;
+  try {
+    extracted = extractor.extract(content, path ?? file);
+  } catch (error) {
+    throw new TermError(`${file}: could not be read as ${format}: ${errorMessage(error)}`);
+  }
+  return {
+    content,
+    file,
+    ...path === void 0 ? {} : { path },
+    format: extractor.name,
+    metadata: extracted.data,
+    lineFor: extracted.lineFor
+  };
+}
+async function loadTermSet(opts) {
+  const { run } = opts;
+  const readers = opts.readers ?? TERM_READERS;
+  const exclude = opts.exclude ?? [];
+  const allowEmpty = opts.allowEmpty ?? run.config?.allowEmpty === true;
+  const usingStdin = run.inputs.includes(STDIN_TOKEN);
+  const inputs = run.inputs.filter((input) => input !== STDIN_TOKEN);
+  if (usingStdin && (opts.as === void 0 || opts.as === "")) {
+    throw new TermError("reading stdin needs --as <format>.");
+  }
+  if (inputs.length === 0 && !usingStdin && run.manifests.length === 0) {
+    throw new TermError(
+      "No files to read. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
+    );
+  }
+  const set = { terms: [], references: [], notices: [] };
+  if (inputs.length > 0) {
+    const { files, gitignoreSkipped, named } = await resolveTargetSet({
+      inputs,
+      cwd: run.base,
+      exclude,
+      ...opts.exts === void 0 ? {} : { exts: opts.exts },
+      allowEmpty,
+      ...gitignoreOptions({
+        ...opts.noGitignore === true ? { flag: false } : {},
+        ...run.config?.respectGitignore === void 0 ? {} : { configured: run.config.respectGitignore },
+        ...opts.onNotice ? { onNotice: opts.onNotice } : {}
+      })
+    });
+    assertNonEmpty({
+      files,
+      inputs,
+      usingStdin,
+      allowEmpty,
+      exclude,
+      ...opts.exts === void 0 ? {} : { exts: opts.exts },
+      gitignoreSkipped,
+      action: "read"
+    });
+    const namedFiles = new Set(named);
+    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);
+        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);
+      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);
+    set.references.push(...referencesOf(input));
+    read7(input, readers, set);
+  }
+  for (const { path, written } of run.manifests) {
+    let content;
+    try {
+      content = await readFile(path, "utf8");
+    } catch {
+      const source = run.configSource ?? "manni.config.yaml";
+      throw new TermError(`${source}: term.manifests "${written}" does not exist.`);
+    }
+    read7(manifestInput(content, path, path), readers, set);
+  }
+  if (set.terms.length === 0 && !allowEmpty) {
+    throw new TermError(
+      "no terms found. A term is a page declaring type: term, or an entry in a file declaring type: term-set."
+    );
+  }
+  return set;
+}
+
+// src/term/commands/run.ts
+async function loadTerms(opts) {
+  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const run = await resolveTermRun({
+    cwd,
+    inputs: opts.inputs,
+    ...opts.configPath === void 0 ? {} : { configPath: opts.configPath },
+    ...opts.collection === void 0 ? {} : { collection: opts.collection }
+  });
+  const set = await loadSet(run, opts);
+  return { cwd, run, set };
+}
+async function loadSet(run, opts) {
+  const exclude = [
+    .../* @__PURE__ */ new Set([
+      ...opts.exclude ?? [],
+      ...run.fromCollections ? run.collections.flatMap((c) => c.exclude) : []
+    ])
+  ];
+  const set = await loadTermSet({
+    run,
+    exclude,
+    ...opts.exts === void 0 ? {} : { exts: opts.exts },
+    ...opts.allowEmpty === true ? { allowEmpty: true } : {},
+    ...opts.noGitignore === true ? { noGitignore: true } : {},
+    ...opts.stdin === void 0 ? {} : { stdin: opts.stdin },
+    ...opts.as === void 0 ? {} : { as: opts.as },
+    ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice },
+    ...opts.readers === void 0 ? {} : { readers: opts.readers }
+  });
+  for (const message of set.notices) opts.onNotice?.(message);
+  return set;
+}
+function formatChoice(value, allowed) {
+  const found = allowed.find((candidate) => candidate === value);
+  if (found === void 0) {
+    throw new TermError(`unknown format "${value}". Expected ${allowed.join(" | ")}.`);
+  }
+  return found;
+}
+function displayPath(path, cwd) {
+  if (!isAbsolute(path)) return path;
+  const rel = relative(cwd, path);
+  return (rel === "" ? "." : rel).replaceAll("\\", "/");
+}
+function valeConfigFor(run) {
+  if (run.configDir === void 0) return void 0;
+  const path = valeConfigPath(run.tools, run.configDir);
+  if (path !== void 0 && !existsSync(path)) {
+    const source = run.configSource ?? "manni.config.yaml";
+    throw new TermError(`${source}: tools.vale.config "${run.tools.vale?.config ?? path}" does not exist.`);
+  }
+  return path;
+}
+function plural(n, one, many = `${one}s`) {
+  return `${String(n)} ${n === 1 ? one : many}`;
+}
+
+export {
+  TermError,
+  TERM_FIELDS,
+  TERM_WRITE_FORMATS,
+  TERM_RULES,
+  DEFAULT_TERM_BASELINE_PATH,
+  DEFAULT_ABSTRACT_MAX_LENGTH,
+  resolveTermRun,
+  xmlText,
+  xmlAttribute,
+  sharedLanguage,
+  reindent,
+  fileOf,
+  LIST_HOLDS,
+  DITA_HOLDS,
+  DOCBOOK_HOLDS,
+  markdownEntry,
+  asciidocEntry,
+  rstEntry,
+  htmlDlEntry,
+  ditaEntry,
+  docbookEntry,
+  TERM_READERS,
+  readerForConstruct,
+  MANIFEST_FORMAT,
+  extractInput,
+  loadTerms,
+  loadSet,
+  formatChoice,
+  displayPath,
+  valeConfigFor,
+  plural
+};
+//# sourceMappingURL=chunk-PU6DFJMY.js.map