@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-G7NJSREW.js

@@ -0,0 +1,979 @@
+#!/usr/bin/env node
+import {
+  codeEndAt,
+  codeRegions
+} from "./chunk-IKEWBMCN.js";
+import {
+  LineRangeError,
+  MAX_RANGE_LINES,
+  hashRange,
+  isKeyedPin,
+  lineSpec,
+  parseLines,
+  sliceLines
+} from "./chunk-RLR4TKUZ.js";
+import {
+  __default3 as __default,
+  extractorByName,
+  extractorForExtension,
+  hasFrontmatterFence,
+  locateFrontmatter,
+  supportedExtensions
+} from "./chunk-JVTNMVYU.js";
+import {
+  isEncryptedValue
+} from "./chunk-Q35YIDBV.js";
+import {
+  ToolError
+} from "./chunk-G3T47CFV.js";
+
+// src/cite/core/page.ts
+import { extname } from "node:path";
+import * as Ajv2020Ns from "ajv/dist/2020.js";
+
+// src/cite/errors.ts
+var CiteError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "CiteError";
+  }
+};
+function asCiteError(call) {
+  try {
+    return call();
+  } catch (error) {
+    if (error instanceof LineRangeError) throw new CiteError(error.message);
+    throw error;
+  }
+}
+
+// src/cite/core/hash.ts
+function sliceLines2(lines, range, label) {
+  return asCiteError(() => sliceLines(lines, range, label));
+}
+function hashRange2(text, range, key) {
+  return asCiteError(() => hashRange(text, range, key));
+}
+
+// src/cite/core/range.ts
+var FILE_PATTERN = /^(?:~[A-Za-z0-9_-]{82,}|(?!~)(?:(?!\.\.?(?:\/|$))[^/\\:\r\n\t]+)(?:\/(?:(?!\.\.?(?:\/|$))[^/\\:\r\n\t]+))*)$/;
+var SRC_PATTERN = /^(?:~[A-Za-z0-9_-]{82,}|(?!~)(?:(?!\.\.?(?:\/|:|$))[^/\\:\r\n\t]+)(?:\/(?:(?!\.\.?(?:\/|:|$))[^/\\:\r\n\t]+))*)(?::[1-9][0-9]*(?:-[1-9][0-9]*)?)?$/;
+function parseSrc(src) {
+  if (!SRC_PATTERN.test(src)) {
+    throw new CiteError(
+      `Invalid src "${src}": expected path, path:L, path:L1-L2, or an encrypted source (~ and at least 82 base64url characters) with the same line forms; the path is repo-root-relative, posix, and free of . and .. segments.`
+    );
+  }
+  const colon = src.indexOf(":");
+  const path = colon === -1 ? src : src.slice(0, colon);
+  const range = { path, encrypted: isEncryptedValue(path) };
+  if (colon === -1) return range;
+  const [startText, endText] = src.slice(colon + 1).split("-");
+  const start = Number(startText);
+  const end = endText === void 0 ? start : Number(endText);
+  if (end < start) {
+    throw new CiteError(`Invalid range "${src}": end line ${end} is before start line ${start}.`);
+  }
+  range.start = start;
+  range.end = end;
+  return range;
+}
+function tooWide(lines) {
+  const width = lines.end - lines.start + 1;
+  return width > MAX_RANGE_LINES ? `spans ${String(width)} lines, more than ${String(MAX_RANGE_LINES)}` : void 0;
+}
+function formatSrc(range) {
+  const { path, start, end } = range;
+  if (start === void 0) return path;
+  if (end === void 0 || end === start) return `${path}:${start}`;
+  return `${path}:${start}-${end}`;
+}
+function sourceRange(source) {
+  const range = { path: source.file, encrypted: isEncryptedValue(source.file) };
+  if (source.lines === void 0) return range;
+  const lines = parseLines(source.lines);
+  if (lines !== void 0) {
+    range.start = lines.start;
+    range.end = lines.end;
+  }
+  return range;
+}
+function spellSource(source) {
+  return formatSrc(sourceRange(source));
+}
+function rangeLines(range) {
+  if (range.start === void 0) return void 0;
+  return lineSpec({ start: range.start, end: range.end ?? range.start });
+}
+
+// src/cite/types.ts
+var CITE_RULES = [
+  "source-moved",
+  "source-moved-ambiguous",
+  "source-changed",
+  "source-never-true",
+  "source-missing",
+  "claim-moved",
+  "claim-moved-ambiguous",
+  "claim-reanchored",
+  "claim-changed",
+  "marker-orphan",
+  "marker-invalid",
+  "marker-repeated",
+  "marker-misplaced",
+  "anchor-invalid",
+  "entry-invalid",
+  "quote-drift"
+];
+
+// src/cite/core/severity.ts
+var DEFAULT_SEVERITY = {
+  "source-moved": "warning",
+  "source-moved-ambiguous": "error",
+  "source-changed": "error",
+  "source-never-true": "error",
+  "source-missing": "error",
+  "claim-moved": "notice",
+  "claim-moved-ambiguous": "warning",
+  "claim-reanchored": "notice",
+  "claim-changed": "warning",
+  "marker-orphan": "error",
+  "marker-invalid": "error",
+  "marker-repeated": "warning",
+  "marker-misplaced": "warning",
+  "anchor-invalid": "error",
+  "entry-invalid": "error",
+  "quote-drift": "error"
+};
+var RULE_ID_PREFIX = "manni:cite";
+function ruleId(rule) {
+  return `${RULE_ID_PREFIX}/${rule}`;
+}
+function isCiteRule(value) {
+  return CITE_RULES.includes(value);
+}
+function resolveSeverity(overrides) {
+  return { ...DEFAULT_SEVERITY, ...overrides ?? {} };
+}
+
+// src/cite/core/statements.ts
+var HTML_COMMENT = { open: "<!--", close: "-->" };
+var JSX_COMMENT = { open: "{/*", close: "*/}" };
+var LINK_REFERENCE = { open: "[comment]: # (", close: ")" };
+var MARKDOWN_FORMS = [HTML_COMMENT, JSX_COMMENT, LINK_REFERENCE];
+var MDX_FORMS = [JSX_COMMENT, HTML_COMMENT, LINK_REFERENCE];
+var COMMENT_FORMS = [{ open: "<!--", close: "-->" }];
+var ASCIIDOC_FORMS = [{ open: "// (", close: ")" }];
+var RST_FORMS = [{ open: ".. (", close: ")" }];
+var ID = /^[a-z0-9][a-z0-9-]*$/;
+var ANY_FENCE = /^(?:[ \t]*(?:`{3,}|~{3,})|-{4,})/;
+var MARKDOWN_FENCE = /^(`{3,}|~{3,})/;
+var ASCIIDOC_FENCE = /^(-{4,})/;
+function statementForms(format) {
+  switch (format) {
+    case "markdown":
+      return MARKDOWN_FORMS;
+    case "mdx":
+      return MDX_FORMS;
+    case "html":
+    case "xml":
+      return COMMENT_FORMS;
+    case "asciidoc":
+      return ASCIIDOC_FORMS;
+    case "rst":
+      return RST_FORMS;
+    default:
+      return [];
+  }
+}
+function fenceFor(format) {
+  switch (format) {
+    case "markdown":
+    case "mdx":
+      return MARKDOWN_FENCE;
+    case "asciidoc":
+      return ASCIIDOC_FENCE;
+    default:
+      return void 0;
+  }
+}
+function lineEnd(content, pos) {
+  const nl = content.indexOf("\n", pos);
+  return nl === -1 ? content.length : nl;
+}
+function lineText(content, pos, end) {
+  const text = content.slice(pos, end);
+  return text.endsWith("\r") ? text.slice(0, -1) : text;
+}
+function beforeCr(content, end) {
+  return end > 0 && content.charCodeAt(end - 1) === 13 ? end - 1 : end;
+}
+function nextLineStart(content, offset) {
+  if (offset === 0 || content.charCodeAt(offset - 1) === 10) return offset;
+  return lineEnd(content, offset) + 1;
+}
+var MAX_IDS_PER_MARKER = 25;
+function payloadOf(payload) {
+  if (payload === "") return { kind: "bad", reason: "empty payload" };
+  if (/[\r\n]/.test(payload)) {
+    return { kind: "bad", reason: "a marker is one line; write two markers" };
+  }
+  const [head, ...rest] = payload.split(" ").filter((word) => word !== "");
+  if (head === void 0) return { kind: "bad", reason: "empty payload" };
+  const words = [head, ...rest];
+  if (words.some((word) => word.startsWith("{"))) {
+    return { kind: "bad", reason: "a JSON payload", json: true };
+  }
+  if (words.length > MAX_IDS_PER_MARKER) {
+    return {
+      kind: "bad",
+      reason: `more than ${String(MAX_IDS_PER_MARKER)} ids in one marker (${String(words.length)}); write a second marker`
+    };
+  }
+  const bad = words.find((word) => !ID.test(word));
+  if (bad !== void 0) return { kind: "bad", reason: `"${bad}" is not an id` };
+  const seen = /* @__PURE__ */ new Set();
+  for (const word of words) {
+    if (seen.has(word)) {
+      return { kind: "bad", reason: `"${word}" is named twice in one marker` };
+    }
+    seen.add(word);
+  }
+  return { kind: "ref", ids: words };
+}
+function isCite(inner) {
+  return inner === "cite" || inner.startsWith("cite") && /\s/.test(inner.charAt(4));
+}
+function isMarkerLine(line, format) {
+  const text = line.trim();
+  return statementForms(format).some((form) => {
+    if (text.length < form.open.length + form.close.length) return false;
+    if (!text.startsWith(form.open)) return false;
+    const closeAt = text.indexOf(form.close, form.open.length);
+    if (closeAt !== text.length - form.close.length) return false;
+    return isCite(text.slice(form.open.length, closeAt).trim());
+  });
+}
+var ATX_HEADING = /^[ \t]*#{1,6}([ \t]|$)/;
+var ASCIIDOC_TITLE = /^={1,6}[ \t]/;
+var ADORNMENT = /^[ \t]*([-=~^"'*+#_:<>])(?:[ \t]*\1){2,}[ \t]*$/;
+var TAG_LINE = /^[ \t]*<\/?[A-Za-z][^<>]*>[ \t]*$/;
+var TABLE_ROW = /^[ \t]*\|/;
+function isTableRow(line) {
+  return TABLE_ROW.test(line);
+}
+var TABLE_RULE = /^(?=[^|]*\|)[ \t]*\|?(?:[ \t]*:?-+:?[ \t]*\|)*[ \t]*:?-+:?[ \t]*\|?[ \t]*$/;
+function isTableSeparator(line) {
+  return TABLE_RULE.test(line);
+}
+function isBoundLine(line, format) {
+  if (ADORNMENT.test(line)) return true;
+  switch (format) {
+    case "markdown":
+    case "mdx":
+      return ATX_HEADING.test(line) || TAG_LINE.test(line);
+    case "html":
+    case "xml":
+      return TAG_LINE.test(line);
+    case "asciidoc":
+      return ASCIIDOC_TITLE.test(line);
+    default:
+      return false;
+  }
+}
+function parseStatements(body, format, from = { offset: 0, line: 1 }) {
+  const out = [];
+  const fileLine = (bodyOffset) => from.line + lineAt(body, bodyOffset) - 1;
+  const code = codeRegions(body, format);
+  for (const form of statementForms(format)) {
+    let cursor = 0;
+    for (; ; ) {
+      const at = body.indexOf(form.open, cursor);
+      if (at === -1) break;
+      const codeEnd = codeEndAt(code, at);
+      if (codeEnd !== void 0) {
+        cursor = codeEnd;
+        continue;
+      }
+      const closeAt = body.indexOf(form.close, at + form.open.length);
+      if (closeAt === -1) break;
+      const end = closeAt + form.close.length;
+      cursor = end;
+      const inner = body.slice(at + form.open.length, closeAt).trim();
+      if (!isCite(inner)) continue;
+      const payload = inner.slice(4).trim();
+      const unit = anchoredLines(body, end, format);
+      const anchorLine = unit === void 0 ? void 0 : from.line + unit.start - 1;
+      const statement = {
+        line: fileLine(at),
+        payload: payloadOf(payload),
+        raw: inner,
+        start: from.offset + at,
+        end: from.offset + end
+      };
+      if (anchorLine !== void 0) statement.anchorLine = anchorLine;
+      out.push(statement);
+    }
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+function detectEol(text) {
+  const nl = text.indexOf("\n");
+  return nl > 0 && text.charCodeAt(nl - 1) === 13 ? "\r\n" : "\n";
+}
+function paragraphAfter(content, offset, format) {
+  const marker = (text) => format !== void 0 && isMarkerLine(text, format);
+  const bound = (text) => format !== void 0 && isBoundLine(text, format);
+  let pos = offset;
+  const firstEnd = lineEnd(content, pos);
+  if (lineText(content, pos, firstEnd).trim() === "") pos = firstEnd + 1;
+  while (pos < content.length) {
+    const end = lineEnd(content, pos);
+    const text = lineText(content, pos, end);
+    if (text.trim() === "" || marker(text)) {
+      pos = end + 1;
+      continue;
+    }
+    if (ANY_FENCE.test(text)) return void 0;
+    const start = pos;
+    let last = end;
+    let cursor = bound(text) ? content.length : end + 1;
+    while (cursor < content.length) {
+      const e = lineEnd(content, cursor);
+      const t = lineText(content, cursor, e);
+      if (t.trim() === "" || ANY_FENCE.test(t) || marker(t) || bound(t)) break;
+      last = e;
+      cursor = e + 1;
+    }
+    return { start, end: beforeCr(content, last), line: lineAt(content, start) };
+  }
+  return void 0;
+}
+function scanFence(content, offset, fence) {
+  let pos = nextLineStart(content, offset);
+  while (pos < content.length) {
+    const end = lineEnd(content, pos);
+    const text = lineText(content, pos, end);
+    const opener = fence.exec(text)?.[1];
+    if (opener === void 0) {
+      pos = end + 1;
+      continue;
+    }
+    const line = lineAt(content, pos);
+    const start = Math.min(end + 1, content.length);
+    let cursor = start;
+    while (cursor < content.length) {
+      const e = lineEnd(content, cursor);
+      if (lineText(content, cursor, e).startsWith(opener)) {
+        return {
+          start,
+          end: cursor,
+          line,
+          text: content.slice(start, cursor),
+          next: e + 1
+        };
+      }
+      cursor = e + 1;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function fencedBlockAfter(content, offset, format) {
+  const fence = fenceFor(format);
+  if (!fence) return void 0;
+  const block = scanFence(content, offset, fence);
+  if (!block) return void 0;
+  const { start, end, line, text } = block;
+  return { start, end, line, text };
+}
+function fencedBlockAt(content, offset) {
+  const pos = nextLineStart(content, offset);
+  if (!ANY_FENCE.test(lineText(content, pos, lineEnd(content, pos)))) {
+    return void 0;
+  }
+  const block = scanFence(content, pos, MARKDOWN_FENCE) ?? scanFence(content, pos, ASCIIDOC_FENCE);
+  if (!block || block.line !== lineAt(content, pos)) return void 0;
+  const { start, end, line, text } = block;
+  return { start, end, line, text };
+}
+function fencedBlocks(content, bodyOffset, format) {
+  const fence = fenceFor(format);
+  if (!fence) return [];
+  const out = [];
+  let pos = bodyOffset;
+  for (; ; ) {
+    const block = scanFence(content, pos, fence);
+    if (!block) return out;
+    const { start, end, line, text } = block;
+    out.push({ start, end, line, text });
+    pos = block.next;
+  }
+}
+function writtenForm(format) {
+  const form = statementForms(format)[0];
+  if (!form) {
+    throw new CiteError(`No marker syntax for format "${format}".`);
+  }
+  return form;
+}
+function formatStatement(format, payload) {
+  const form = writtenForm(format);
+  const pad = form.open.endsWith("(") ? "" : " ";
+  return `${form.open}${pad}cite ${payload.ids.join(" ")}${pad}${form.close}`;
+}
+function respellEdit(content, statement, ids) {
+  const text = content.slice(statement.start, statement.end);
+  const at = text.indexOf(statement.raw);
+  if (at === -1) return void 0;
+  return {
+    start: statement.start + at,
+    end: statement.start + at + statement.raw.length,
+    text: `cite ${ids.join(" ")}`
+  };
+}
+function respellStatement(content, statement, ids) {
+  const edit = respellEdit(content, statement, ids);
+  if (edit === void 0) return content;
+  return content.slice(0, edit.start) + edit.text + content.slice(edit.end);
+}
+function nextTextLine(text, offset, format) {
+  let pos = nextLineStart(text, offset);
+  while (pos < text.length) {
+    const end = lineEnd(text, pos);
+    const line = lineText(text, pos, end);
+    if (line.trim() !== "" && !isMarkerLine(line, format)) return lineAt(text, pos);
+    pos = end + 1;
+  }
+  return void 0;
+}
+function fenceSpanAt(text, line, format) {
+  const fence = fenceFor(format);
+  if (!fence) return void 0;
+  const block = scanFence(text, offsetOfLine(text, line), fence);
+  if (!block || block.line !== line) return void 0;
+  return { start: line, end: lineAt(text, block.end) };
+}
+function fenceAround(text, bodyOffset, line, format) {
+  const block = fencedBlocks(text, bodyOffset, format).find(
+    (b) => line > b.line && line <= lineAt(text, b.end)
+  );
+  return block === void 0 ? void 0 : { start: block.line, end: lineAt(text, block.end) };
+}
+function insideFence(text, bodyOffset, line, format) {
+  return fenceAround(text, bodyOffset, line, format) !== void 0;
+}
+function unitHolding(text, line, format, body) {
+  const textOf = (n) => lineText(text, offsetOfLine(text, n), lineEnd(text, offsetOfLine(text, n)));
+  const own = textOf(line);
+  if (own.trim() === "" || isMarkerLine(own, format)) return void 0;
+  const block = fencedBlocks(text, body.offset, format).find(
+    (b) => line >= b.line && line <= lineAt(text, b.end)
+  );
+  if (block !== void 0) {
+    return { start: block.line, end: lineAt(text, block.end), kind: "block" };
+  }
+  if (ANY_FENCE.test(own)) return void 0;
+  let start = line;
+  while (start - 1 >= body.line && !isBoundLine(own, format)) {
+    const above = textOf(start - 1);
+    if (above.trim() === "" || ANY_FENCE.test(above) || isMarkerLine(above, format) || isBoundLine(above, format)) {
+      break;
+    }
+    start--;
+  }
+  const paragraph = paragraphAfter(text, offsetOfLine(text, start), format);
+  if (paragraph?.line !== start) return void 0;
+  return { start, end: lineAt(text, paragraph.end), kind: "paragraph" };
+}
+var LIST_ITEM = /^([ \t]*)([-*+]|\d{1,9}[.)])([ \t]+|$)/;
+var THEMATIC_BREAK = /^[ \t]*([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+function textOfLine(text, n) {
+  const pos = offsetOfLine(text, n);
+  return lineText(text, pos, lineEnd(text, pos));
+}
+function indentOf(line) {
+  return /^[ \t]*/.exec(line)?.[0] ?? "";
+}
+function columnOf(indent) {
+  let column = 0;
+  for (const ch of indent) column = ch === "	" ? column + 4 - column % 4 : column + 1;
+  return column;
+}
+function listItemOf(line) {
+  if (THEMATIC_BREAK.test(line)) return void 0;
+  const match = LIST_ITEM.exec(line);
+  if (match === null) return void 0;
+  const [, lead = "", bullet = "", gap = ""] = match;
+  return { lead, bullet, gap };
+}
+function continuesList(text, line, format, bodyLine, column) {
+  let n = line - 1;
+  while (n >= bodyLine) {
+    const above = textOfLine(text, n);
+    if (above.trim() !== "" && !isMarkerLine(above, format)) break;
+    n--;
+  }
+  if (n < bodyLine) return false;
+  if (columnOf(indentOf(textOfLine(text, n))) > column) return true;
+  for (; n >= bodyLine; n--) {
+    const above = textOfLine(text, n);
+    if (above.trim() === "" || ANY_FENCE.test(above) || isMarkerLine(above, format) || isBoundLine(above, format)) {
+      break;
+    }
+    const item = listItemOf(above);
+    if (item !== void 0 && columnOf(item.lead) === column) return true;
+  }
+  return false;
+}
+function markerIndent(text, line, format, bodyLine) {
+  if (format === "asciidoc") return "";
+  const own = textOfLine(text, line);
+  const indent = indentOf(own);
+  if (format !== "markdown" && format !== "mdx") return indent;
+  const item = listItemOf(own);
+  if (item === void 0 || !continuesList(text, line, format, bodyLine, columnOf(item.lead))) {
+    return indent;
+  }
+  const gap = item.gap === "" || columnOf(item.gap) > 4 ? " " : item.gap;
+  return item.lead + " ".repeat(item.bullet.length) + gap;
+}
+function anchoredLines(text, after, format, quote = false) {
+  if (quote) {
+    const block = fencedBlockAfter(text, after, format);
+    return block === void 0 ? void 0 : { start: block.line, end: lineAt(text, block.end) };
+  }
+  const restEnd = lineEnd(text, after);
+  if (text.slice(after, restEnd).trim() !== "") {
+    const line2 = lineAt(text, after);
+    return { start: line2, end: line2 };
+  }
+  const paragraph = paragraphAfter(text, after, format);
+  if (paragraph !== void 0) {
+    return { start: paragraph.line, end: lineAt(text, paragraph.end) };
+  }
+  const line = nextTextLine(text, after, format);
+  return line === void 0 ? void 0 : fenceSpanAt(text, line, format);
+}
+var LINE_INDEX_SLOTS = 4;
+var lineIndexes = [];
+function newlinesOf(content) {
+  const hit = lineIndexes.findIndex((entry) => entry.text === content);
+  const found = hit === -1 ? void 0 : lineIndexes[hit];
+  if (found !== void 0) return found.newlines;
+  const newlines = [];
+  for (let at = content.indexOf("\n"); at !== -1; at = content.indexOf("\n", at + 1)) newlines.push(at);
+  lineIndexes.unshift({ text: content, newlines });
+  lineIndexes.length = Math.min(lineIndexes.length, LINE_INDEX_SLOTS);
+  return newlines;
+}
+function lineAt(content, offset) {
+  const stop = Math.min(offset, content.length);
+  const newlines = newlinesOf(content);
+  let low = 0;
+  let high = newlines.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((newlines[mid] ?? Infinity) < stop) low = mid + 1;
+    else high = mid;
+  }
+  return low + 1;
+}
+function offsetOfLine(content, line) {
+  if (line <= 1) return 0;
+  const before = newlinesOf(content)[line - 2];
+  return before === void 0 ? content.length : before + 1;
+}
+
+// src/cite/core/page.ts
+var MAX_MARKERS_PER_PAGE = 500;
+var ELEMENT_BACKED = /* @__PURE__ */ new Set(["html", "xml"]);
+var FENCE_ONLY = /* @__PURE__ */ new Set(["markdown", "mdx"]);
+var MARKER_JSON = "A marker names an entry by id. Write the entry in frontmatter or the sidecar.";
+function ownedMessage(owner) {
+  return `"citations" is owned by manifest ${owner.file} (collection ${owner.collection}); remove it from the document`;
+}
+var Ajv2020 = Ajv2020Ns.default;
+var entryValidator;
+function compileEntryValidator() {
+  if (entryValidator) return entryValidator;
+  const ajv = new Ajv2020({ allErrors: false, strict: false });
+  ajv.addSchema(__default);
+  entryValidator = ajv.compile({
+    $ref: `${__default.$id}#/$defs/citationEntry`
+  });
+  return entryValidator;
+}
+function validateEntry(entry) {
+  const validate = compileEntryValidator();
+  if (validate(entry)) return void 0;
+  const first = validate.errors?.[0];
+  if (!first) return "invalid entry";
+  return `${first.instancePath} ${first.message ?? "is invalid"}`.trim();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toCitation(entry) {
+  const source = isRecord(entry.source) ? entry.source : {};
+  const citation = {
+    source: {
+      file: String(source.file),
+      integrity: String(source.integrity)
+    }
+  };
+  if (typeof source.lines === "number" || typeof source.lines === "string") {
+    citation.source.lines = source.lines;
+  }
+  if (typeof source["commit-sha"] === "string") {
+    citation.source["commit-sha"] = source["commit-sha"];
+  }
+  if (typeof entry.id === "string") citation.id = entry.id;
+  if (isRecord(entry.claim)) {
+    const claim = entry.claim;
+    citation.claim = { integrity: String(claim.integrity) };
+    if (typeof claim.lines === "number" || typeof claim.lines === "string") {
+      citation.claim.lines = claim.lines;
+    }
+  }
+  if (typeof entry.quote === "boolean") citation.quote = entry.quote;
+  return citation;
+}
+function finding(rule, message, extra) {
+  const level = DEFAULT_SEVERITY[rule];
+  const out = {
+    rule,
+    ruleId: ruleId(rule),
+    // The caller re-applies the configured severity table; no page-side rule
+    // defaults to `off`, so there is nothing to collapse.
+    severity: level === "off" ? "error" : level,
+    message
+  };
+  if (extra.line !== void 0) out.line = extra.line;
+  if (extra.file !== void 0) out.file = extra.file;
+  if (extra.id !== void 0) out.id = extra.id;
+  if (extra.src !== void 0) out.src = extra.src;
+  if (extra.index !== void 0) out.index = extra.index;
+  return out;
+}
+function named(id, text) {
+  return id === void 0 ? text : `${id}: ${text}`;
+}
+function subjectOf(entry) {
+  const out = {};
+  if (!isRecord(entry)) return out;
+  if (typeof entry.id === "string") out.id = entry.id;
+  if (isRecord(entry.source) && typeof entry.source.file === "string") out.src = entry.source.file;
+  return out;
+}
+function pickExtractor(file, format) {
+  if (format !== void 0) {
+    const forced = extractorByName(format);
+    if (forced === void 0) {
+      throw new CiteError(
+        `Unknown format "${format}". Supported extensions: ${supportedExtensions().join(", ")}.`
+      );
+    }
+    return forced;
+  }
+  const extension = extname(file);
+  const byExt = extractorForExtension(extension);
+  if (!byExt) {
+    throw new CiteError(
+      `Unsupported file type "${extension}" for "${file}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
+    );
+  }
+  return byExt;
+}
+function byLine(a, b) {
+  return (a.line ?? Number.MAX_SAFE_INTEGER) - (b.line ?? Number.MAX_SAFE_INTEGER);
+}
+function bodyLineOf(content, bodyOffset) {
+  if (bodyOffset <= 0) return 1;
+  const line = lineAt(content, bodyOffset);
+  return content.charCodeAt(bodyOffset - 1) === 10 ? line : line + 1;
+}
+function citationInputs(file, extracted, injected) {
+  if (injected !== void 0) return [...injected];
+  const raw = extracted.data.citations;
+  const list = Array.isArray(raw) ? raw : [];
+  return list.map((entry, index) => {
+    const origin = { kind: "frontmatter", file };
+    const line = extracted.lineFor(`/citations/${String(index)}`);
+    if (line !== void 0) origin.line = line;
+    return { entry, origin };
+  });
+}
+function readPage(file, content, opts) {
+  const extractor = pickExtractor(file, opts?.format);
+  const format = extractor.name;
+  if (FENCE_ONLY.has(format) && hasFrontmatterFence(content) && locateFrontmatter(content) === null) {
+    throw new CiteError(
+      `${file}: Unterminated front matter fence: the opening fence has no matching close, so the page's citations cannot be read. Add a closing fence.`
+    );
+  }
+  const extracted = extractor.extract(content, file);
+  const data = extracted.data;
+  const bodyOffset = ELEMENT_BACKED.has(format) ? 0 : locateFrontmatter(content)?.closeEnd ?? 0;
+  const bodyLine = bodyLineOf(content, bodyOffset);
+  const findings = [];
+  const citations = [];
+  const byId = /* @__PURE__ */ new Map();
+  const ids = /* @__PURE__ */ new Set();
+  const markedAt = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(data)) {
+    if (!key.startsWith("citation-")) continue;
+    findings.push(
+      finding(
+        "entry-invalid",
+        `"${key}" is not a citations key; the page root reserves the citation- prefix`,
+        { line: extracted.lineFor(`/${key}`) }
+      )
+    );
+  }
+  const injected = opts?.citations;
+  const rawCitations = data.citations;
+  if (opts?.owned !== void 0 && rawCitations !== void 0) {
+    findings.push(
+      finding("entry-invalid", ownedMessage(opts.owned), {
+        line: extracted.lineFor("/citations")
+      })
+    );
+  }
+  if (injected === void 0 && rawCitations !== void 0 && !Array.isArray(rawCitations)) {
+    findings.push(
+      finding("entry-invalid", "citations must be an array of entries", {
+        line: extracted.lineFor("/citations")
+      })
+    );
+  }
+  const inputs = citationInputs(file, extracted, injected);
+  inputs.forEach((input, index) => {
+    const origin = { ...input.origin, index };
+    const where = { index };
+    if (origin.line !== void 0) where.line = origin.line;
+    if (origin.kind === "manifest") where.file = origin.file;
+    const entry = input.entry;
+    const error = validateEntry(entry);
+    if (error !== void 0 || !isRecord(entry)) {
+      findings.push(finding("entry-invalid", error ?? "must be object", { ...where, ...subjectOf(entry) }));
+      return;
+    }
+    const citation = toCitation(entry);
+    const subject = { ...where, src: spellSource(citation.source) };
+    if (citation.id !== void 0) subject.id = citation.id;
+    const bad = ["claim", "source"].find((end) => {
+      const lines = end === "claim" ? citation.claim?.lines : citation.source.lines;
+      return lines !== void 0 && parseLines(lines) === void 0;
+    });
+    if (bad !== void 0) {
+      const lines = bad === "claim" ? citation.claim?.lines : citation.source.lines;
+      findings.push(
+        finding(
+          "entry-invalid",
+          named(citation.id, `${bad}.lines "${String(lines)}" ends before it starts`),
+          subject
+        )
+      );
+      return;
+    }
+    const wide = ["claim", "source"].map((end) => {
+      const lines = end === "claim" ? citation.claim?.lines : citation.source.lines;
+      const parsed = lines === void 0 ? void 0 : parseLines(lines);
+      const reason = parsed === void 0 ? void 0 : tooWide(parsed);
+      return reason === void 0 ? void 0 : `${end}.lines "${String(lines)}" ${reason}`;
+    }).find((message) => message !== void 0);
+    if (wide !== void 0) {
+      findings.push(finding("entry-invalid", named(citation.id, wide), subject));
+      return;
+    }
+    const encrypted = isEncryptedValue(citation.source.file);
+    if (encrypted !== isKeyedPin(citation.source.integrity)) {
+      findings.push(
+        finding(
+          "entry-invalid",
+          named(
+            citation.id,
+            encrypted ? "an encrypted source is pinned with hmac-sha256-, not sha256-." : "a plain source is pinned with sha256-, not hmac-sha256-."
+          ),
+          subject
+        )
+      );
+      return;
+    }
+    const page = { citation, origin };
+    citations.push(page);
+    if (citation.id !== void 0) {
+      if (ids.has(citation.id)) {
+        findings.push(finding("entry-invalid", `duplicate id "${citation.id}"`, subject));
+      } else {
+        ids.add(citation.id);
+        byId.set(citation.id, page);
+      }
+    }
+  });
+  const body = content.slice(bodyOffset);
+  const statements = opts?.markers === false ? [] : parseStatements(body, format, { offset: bodyOffset, line: bodyLine });
+  if (statements.length > MAX_MARKERS_PER_PAGE) {
+    findings.push(
+      finding(
+        "marker-invalid",
+        `more than ${String(MAX_MARKERS_PER_PAGE)} markers on one page (${String(statements.length)}); the rest are not read`,
+        { line: statements[MAX_MARKERS_PER_PAGE]?.line }
+      )
+    );
+  }
+  for (const statement of statements.slice(0, MAX_MARKERS_PER_PAGE)) {
+    const { payload } = statement;
+    if (payload.kind === "bad") {
+      findings.push(
+        finding(
+          "marker-invalid",
+          payload.json === true ? MARKER_JSON : `invalid marker: ${payload.reason}`,
+          { line: statement.line }
+        )
+      );
+      continue;
+    }
+    const anchored = [];
+    for (const id of payload.ids) {
+      const target = byId.get(id);
+      if (target === void 0) {
+        findings.push(
+          finding("marker-orphan", `no entry has id "${id}"`, {
+            line: statement.line,
+            id
+          })
+        );
+        continue;
+      }
+      const first = markedAt.get(target);
+      if (first !== void 0) {
+        findings.push(
+          finding(
+            "marker-repeated",
+            `${id} is named by markers at lines ${String(first)} and ${String(statement.line)}; the first anchors it.`,
+            {
+              line: statement.line,
+              id,
+              index: target.origin.index,
+              src: spellSource(target.citation.source)
+            }
+          )
+        );
+        continue;
+      }
+      markedAt.set(target, statement.line);
+      target.marker = statement;
+      anchored.push(target);
+    }
+    const quoted = anchored.find((entry) => entry.citation.quote === true);
+    const plain = anchored.find((entry) => entry.citation.quote !== true);
+    if (quoted !== void 0 && plain !== void 0) {
+      const mixed = {
+        line: statement.line,
+        index: quoted.origin.index,
+        src: spellSource(quoted.citation.source)
+      };
+      if (quoted.citation.id !== void 0) mixed.id = quoted.citation.id;
+      findings.push(
+        finding(
+          "anchor-invalid",
+          named(
+            quoted.citation.id,
+            "a quote entry shares a marker with a non-quote entry. Give the quote its own marker."
+          ),
+          mixed
+        )
+      );
+    }
+  }
+  for (const entry of citations) {
+    const { citation, origin, marker } = entry;
+    const subject = { index: origin.index, src: spellSource(citation.source) };
+    if (citation.id !== void 0) subject.id = citation.id;
+    if (origin.line !== void 0) subject.line = origin.line;
+    if (origin.kind === "manifest") subject.file = origin.file;
+    if (citation.claim?.lines !== void 0 && marker !== void 0) {
+      const onPage = { index: origin.index, line: marker.line, src: subject.src };
+      if (citation.id !== void 0) onPage.id = citation.id;
+      findings.push(
+        finding(
+          "anchor-invalid",
+          `${citation.id ?? "the entry"} has claim lines and a marker. Keep one.`,
+          onPage
+        )
+      );
+      continue;
+    }
+    if (citation.quote === true && citation.claim?.lines === void 0 && marker === void 0) {
+      findings.push(
+        finding("anchor-invalid", named(citation.id, "quote needs a claim or a marker."), subject)
+      );
+    }
+  }
+  return {
+    file,
+    format,
+    content,
+    bodyOffset,
+    bodyLine,
+    citations,
+    statements,
+    findings: findings.sort(byLine)
+  };
+}
+
+export {
+  CiteError,
+  asCiteError,
+  sliceLines2 as sliceLines,
+  hashRange2 as hashRange,
+  FILE_PATTERN,
+  SRC_PATTERN,
+  parseSrc,
+  tooWide,
+  formatSrc,
+  sourceRange,
+  spellSource,
+  rangeLines,
+  CITE_RULES,
+  DEFAULT_SEVERITY,
+  RULE_ID_PREFIX,
+  ruleId,
+  isCiteRule,
+  resolveSeverity,
+  ANY_FENCE,
+  statementForms,
+  MAX_IDS_PER_MARKER,
+  isMarkerLine,
+  isTableRow,
+  isTableSeparator,
+  isBoundLine,
+  parseStatements,
+  detectEol,
+  paragraphAfter,
+  fencedBlockAfter,
+  fencedBlockAt,
+  fencedBlocks,
+  formatStatement,
+  respellEdit,
+  respellStatement,
+  fenceSpanAt,
+  fenceAround,
+  insideFence,
+  unitHolding,
+  markerIndent,
+  anchoredLines,
+  lineAt,
+  offsetOfLine,
+  MAX_MARKERS_PER_PAGE,
+  MARKER_JSON,
+  ownedMessage,
+  validateEntry,
+  pickExtractor,
+  bodyLineOf,
+  citationInputs,
+  readPage
+};
+//# sourceMappingURL=chunk-G7NJSREW.js.map