@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-252LNOEG.js

@@ -0,0 +1,622 @@
+#!/usr/bin/env node
+import {
+  ANY_FENCE,
+  MAX_MARKERS_PER_PAGE,
+  RULE_ID_PREFIX,
+  anchoredLines,
+  fenceAround,
+  fenceSpanAt,
+  isBoundLine,
+  isMarkerLine,
+  isTableRow,
+  isTableSeparator,
+  lineAt,
+  offsetOfLine,
+  paragraphAfter,
+  parseSrc,
+  ruleId
+} from "./chunk-G7NJSREW.js";
+import {
+  findWindows,
+  hashLines,
+  parseLines,
+  pinOfLines,
+  spellLines,
+  toBodyLines,
+  toFileLines
+} from "./chunk-RLR4TKUZ.js";
+import {
+  isErrorSeverity
+} from "./chunk-JVTNMVYU.js";
+
+// src/cite/core/spell.ts
+function shortPin(integrity) {
+  const m = /^((?:hmac-)?sha256-)([0-9a-f]{8})/i.exec(integrity);
+  const prefix = m?.[1];
+  const digits = m?.[2];
+  if (prefix === void 0 || digits === void 0) return integrity;
+  return `${prefix}${digits}\u2026`;
+}
+function shortCommit(commit) {
+  return commit.slice(0, 7);
+}
+function shortSrc(src) {
+  if (!src.startsWith("~")) return src;
+  const colon = src.indexOf(":");
+  const token = colon === -1 ? src : src.slice(0, colon);
+  const lines = colon === -1 ? "" : src.slice(colon);
+  return token.length <= 5 ? src : `${token.slice(0, 5)}\u2026${lines}`;
+}
+var LINE_WIDTH = 60;
+function shortLine(text) {
+  const one = text.replace(/\s+/g, " ").trim();
+  return one.length <= LINE_WIDTH ? one : `${one.slice(0, LINE_WIDTH)}\u2026`;
+}
+function spellAt(lines) {
+  return lines.start === lines.end ? `line ${String(lines.start)}` : `lines ${String(lines.start)}-${String(lines.end)}`;
+}
+function listOf(values) {
+  if (values.length <= 1) return values.join("");
+  return `${values.slice(0, -1).join(", ")} and ${values[values.length - 1] ?? ""}`;
+}
+
+// src/cite/core/adapt.ts
+import { isAbsolute } from "node:path";
+
+// src/cite/core/reanchor.ts
+function isUnitText(line, format) {
+  if (line === void 0) return false;
+  if (line.trim() === "") return false;
+  if (ANY_FENCE.test(line)) return false;
+  if (isMarkerLine(line, format)) return false;
+  return !isBoundLine(line, format);
+}
+function markerAt(lines, n, format) {
+  const line = lines[n - 1];
+  return line !== void 0 && isMarkerLine(line, format);
+}
+function markerRunAt(lines, line, format, bodyLine) {
+  let start = line;
+  while (start - 1 >= bodyLine && markerAt(lines, start - 1, format)) start--;
+  let end = line;
+  while (end + 1 <= lines.length && markerAt(lines, end + 1, format)) end++;
+  return { start, end };
+}
+function splitUnit(lines, run, format, bodyLine) {
+  if (run.start - 1 < bodyLine) return void 0;
+  if (!isUnitText(lines[run.start - 2], format)) return void 0;
+  if (!isUnitText(lines[run.end], format)) return void 0;
+  let start = run.start - 1;
+  while (start - 1 >= bodyLine && isUnitText(lines[start - 2], format)) start--;
+  let end = run.end + 1;
+  while (end + 1 <= lines.length && isUnitText(lines[end], format)) end++;
+  return { start, end };
+}
+function pre43Span(lines, markerLine) {
+  const start = markerLine + 1;
+  const first = lines[start - 1];
+  if (first === void 0 || first.trim() === "" || ANY_FENCE.test(first)) return void 0;
+  let end = start;
+  while (end + 1 <= lines.length) {
+    const next = lines[end];
+    if (next === void 0 || next.trim() === "" || ANY_FENCE.test(next)) break;
+    end++;
+  }
+  return { start, end };
+}
+function runLength(run) {
+  return run.end - run.start + 1;
+}
+function misplacedMarkerAt(page, lines, line, entry) {
+  if (!markerAt(lines, line, page.format)) return void 0;
+  const run = markerRunAt(lines, line, page.format, page.bodyLine);
+  const unit = splitUnit(lines, run, page.format, page.bodyLine);
+  if (unit === void 0) return void 0;
+  const order = line - run.start;
+  const quote = entry?.citation.quote === true;
+  const marker = entry?.marker;
+  const blockAt = quote && marker !== void 0 ? anchoredLines(page.content, marker.end, page.format, true)?.start : void 0;
+  const out = blockAt === void 0 ? { line, run, order, unit, place: unit.start, block: false, to: unit.start + order } : {
+    line,
+    run,
+    order,
+    unit,
+    place: blockAt,
+    block: true,
+    to: blockAt - runLength(run) + order
+  };
+  if (entry !== void 0) out.entry = entry;
+  return out;
+}
+function misplacedMarkers(page, lines) {
+  const out = [];
+  for (const statement of page.statements.slice(0, MAX_MARKERS_PER_PAGE)) {
+    const entry = page.citations.find((c) => c.marker?.line === statement.line);
+    const found = misplacedMarkerAt(page, lines, statement.line, entry);
+    if (found !== void 0) out.push(found);
+  }
+  return out;
+}
+function movedUnit(misplaced) {
+  return { start: misplaced.unit.start + runLength(misplaced.run), end: misplaced.unit.end };
+}
+function unitText(lines, misplaced) {
+  const { unit, run } = misplaced;
+  const out = [];
+  for (let n = unit.start; n <= unit.end; n++) {
+    if (n >= run.start && n <= run.end) continue;
+    const line = lines[n - 1];
+    if (line !== void 0) out.push(line);
+  }
+  return out;
+}
+function splitKeepingEol(content) {
+  const parts = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+  const texts = [];
+  const eols = [];
+  for (const part of parts) {
+    const eol = /\r?\n$/.exec(part)?.[0] ?? "";
+    texts.push(part.slice(0, part.length - eol.length));
+    eols.push(eol);
+  }
+  return { texts, eols };
+}
+function applyMarkerMoves(content, moves, indentAt) {
+  const { texts, eols } = splitKeepingEol(content);
+  const moving = new Set(moves.map((move) => move.from));
+  const inserts = /* @__PURE__ */ new Map();
+  for (const move of moves) {
+    const list = inserts.get(move.place) ?? [];
+    list.push(move.from);
+    inserts.set(move.place, list);
+  }
+  const order = [];
+  for (let n = 1; n <= texts.length; n++) {
+    for (const from of inserts.get(n) ?? []) order.push(from);
+    if (!moving.has(n)) order.push(n);
+  }
+  const moved = /* @__PURE__ */ new Map();
+  for (const move of moves) {
+    moved.set(move.from, indentAt(move.place) + (texts[move.from - 1] ?? "").trim());
+  }
+  const at2 = /* @__PURE__ */ new Map();
+  order.forEach((old, index) => at2.set(old, index + 1));
+  const out = order.map((old, index) => (moved.get(old) ?? texts[old - 1] ?? "") + (eols[index] ?? "")).join("");
+  return { content: out, line: (old) => at2.get(old) ?? old };
+}
+function pinOf(lines, span) {
+  if (span.start < 1 || span.end > lines.length || span.end < span.start) return void 0;
+  return hashLines(lines.slice(span.start - 1, span.end).join("\n"));
+}
+function markerClaimEnd(page, entry, lines, misplaced) {
+  const { citation, marker } = entry;
+  const pin = citation.claim?.integrity;
+  const quote = citation.quote === true;
+  if (marker === void 0 || pin === void 0) return { status: "changed" };
+  const current = anchoredLines(page.content, marker.end, page.format, quote);
+  if (current === void 0) return { status: "changed" };
+  const claimAt = (span, status, to) => {
+    const end = { fileLines: spellLines(span), status };
+    if (to !== void 0) {
+      end.newLines = spellLines(to);
+      end.newFileLines = end.newLines;
+    }
+    if (status === "changed") end.text = lines.slice(span.start - 1, Math.min(span.end, lines.length));
+    return end;
+  };
+  if (quote) {
+    return claimAt(current, pinOf(lines, current) === pin ? "current" : "changed");
+  }
+  if (misplaced !== void 0) {
+    const to = movedUnit(misplaced);
+    if (hashLines(unitText(lines, misplaced).join("\n")) === pin) return claimAt(to, "current");
+    if (pinOf(lines, current) === pin) return claimAt(current, "moved", to);
+    const pre432 = pre43Span(lines, marker.line);
+    if (pre432 !== void 0 && pinOf(lines, pre432) === pin) return claimAt(pre432, "moved", to);
+    return claimAt(current, "changed");
+  }
+  if (pinOf(lines, current) === pin) return claimAt(current, "current");
+  const pre43 = pre43Span(lines, marker.line);
+  if (pre43 !== void 0 && pinOf(lines, pre43) === pin) return claimAt(pre43, "moved", current);
+  return claimAt(current, "changed");
+}
+
+// src/cite/core/claims.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizeBlock(text) {
+  let out = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  out = out.replace(/\r\n/g, "\n");
+  return out.endsWith("\n") ? out.slice(0, -1) : out;
+}
+function blockMatches(blockText, citedJoined) {
+  return normalizeBlock(blockText) === normalizeBlock(citedJoined);
+}
+function textAt(lines, range) {
+  return lines.slice(range.start - 1, Math.min(range.end, lines.length));
+}
+function claimLine(claim) {
+  const at2 = claim.fileLines === void 0 ? void 0 : parseLines(claim.fileLines);
+  return at2?.start;
+}
+function claimLineNow(claim) {
+  const spec = claim.newFileLines ?? claim.candidateFileLines?.[0] ?? claim.fileLines;
+  const at2 = spec === void 0 ? void 0 : parseLines(spec);
+  return at2?.start;
+}
+function claimLinesNow(claim) {
+  const spec = claim.newFileLines ?? claim.candidateFileLines?.[0] ?? claim.fileLines;
+  return spec === void 0 ? void 0 : parseLines(spec);
+}
+function claimEnd(page, entry, lines, misplaced) {
+  const { citation, marker } = entry;
+  const claim = citation.claim;
+  if (claim === void 0) return null;
+  const body = page.bodyLine;
+  if (claim.lines !== void 0) {
+    const recorded = parseLines(claim.lines);
+    if (recorded === void 0) return { status: "skipped" };
+    const file = toFileLines(recorded, body);
+    const end = {
+      lines: spellLines(recorded),
+      fileLines: spellLines(file),
+      status: "changed"
+    };
+    if (marker !== void 0) return { ...end, status: "skipped" };
+    if (pinOfLines(lines, file) === claim.integrity) return { ...end, status: "current" };
+    const width = recorded.end - recorded.start + 1;
+    const found = findWindows(lines.slice(body - 1), width, claim.integrity, void 0, {
+      around: recorded.start
+    });
+    const spans = found.starts.map((start) => ({ start, end: start + width - 1 }));
+    const [only] = spans;
+    if (spans.length === 1 && only !== void 0) {
+      return {
+        ...end,
+        status: "moved",
+        newLines: spellLines(only),
+        newFileLines: spellLines(toFileLines(only, body))
+      };
+    }
+    if (spans.length > 1) {
+      return {
+        ...end,
+        status: "moved-ambiguous",
+        candidates: spans.map(spellLines),
+        candidateFileLines: spans.map((span) => spellLines(toFileLines(span, body)))
+      };
+    }
+    return { ...end, text: textAt(lines, file) };
+  }
+  if (marker !== void 0) {
+    return markerClaimEnd(
+      page,
+      entry,
+      lines,
+      misplaced ?? misplacedMarkerAt(page, lines, marker.line, entry)
+    );
+  }
+  return { status: "changed" };
+}
+function otherClaimSpans(lines, pageLines, pin, bodyLine) {
+  const width = pageLines.end - pageLines.start + 1;
+  const found = findWindows(lines.slice(bodyLine - 1), width, pin, void 0, {
+    around: toBodyLines(pageLines, bodyLine).start
+  });
+  return found.starts.map((start) => toFileLines({ start, end: start + width - 1 }, bodyLine)).filter((span) => span.start !== pageLines.start);
+}
+var NAMED_SPANS = 3;
+function spellElsewhere(spans) {
+  const first = spans[0];
+  const noun = spans.length === 1 && first !== void 0 && first.start === first.end ? "line" : "lines";
+  const named2 = spans.slice(0, NAMED_SPANS).map((span) => spellLines(span));
+  const rest = spans.length - named2.length;
+  if (rest > 0) return `${noun} ${named2.join(", ")} and ${String(rest)} more`;
+  const last = named2.pop() ?? "";
+  return named2.length === 0 ? `${noun} ${last}` : `${noun} ${named2.join(", ")} and ${last}`;
+}
+function spanOf(line, recorded) {
+  const width = recorded === void 0 ? 1 : Math.max(1, recorded.end - recorded.start + 1);
+  return { start: line, end: line + width - 1 };
+}
+function rowsAt(line, lines, recorded, named2) {
+  const end = spanOf(line, recorded).end;
+  if (end > lines.length) return "table-short";
+  for (let n = line; n <= end; n++) {
+    if (!isTableRow(lines[n - 1] ?? "")) return "table-short";
+  }
+  const text = lines.slice(line - 1, end);
+  if (!named2 && text.every((row) => isTableSeparator(row))) return "table-rule";
+  return { lines: { start: line, end }, kind: "paragraph", text };
+}
+function unitOrWhy(page, line, lines, recorded, named2 = false) {
+  if (line < page.bodyLine || line > lines.length) return "outside";
+  const own = lines[line - 1] ?? "";
+  if (own.trim() === "") return "blank";
+  const marker = isMarkerLine(own, page.format);
+  if (marker && !named2) return "marker";
+  const block = fenceSpanAt(page.content, line, page.format);
+  if (block !== void 0) {
+    return { lines: block, kind: "block", text: lines.slice(block.start - 1, block.end) };
+  }
+  const around = fenceAround(page.content, page.bodyOffset, line, page.format);
+  if (around !== void 0) {
+    const span2 = spanOf(line, recorded);
+    return span2.end < around.end ? { lines: span2, kind: "fenced-lines", text: lines.slice(span2.start - 1, span2.end) } : "fence-crossed";
+  }
+  if (isTableRow(own)) return rowsAt(line, lines, recorded, named2);
+  const paragraph = paragraphAfter(
+    page.content,
+    offsetOfLine(page.content, line),
+    marker ? void 0 : page.format
+  );
+  if (paragraph === void 0 || paragraph.line !== line) return "not-a-paragraph";
+  const span = { start: line, end: lineAt(page.content, paragraph.end) };
+  return { lines: span, kind: "paragraph", text: lines.slice(span.start - 1, span.end) };
+}
+function unitAt(page, line, lines, recorded, named2 = false) {
+  const found = unitOrWhy(page, line, lines, recorded, named2);
+  return typeof found === "string" ? void 0 : found;
+}
+function noUnitAt(page, line, lines, recorded, named2 = false) {
+  const found = unitOrWhy(page, line, lines, recorded, named2);
+  return typeof found === "string" ? found : void 0;
+}
+function markerUnit(page, entry, lines) {
+  const { marker, citation } = entry;
+  if (marker === void 0) return void 0;
+  const span = anchoredLines(page.content, marker.end, page.format, citation.quote === true);
+  if (span === void 0 || span.end > lines.length) return void 0;
+  return {
+    lines: span,
+    kind: citation.quote === true ? "block" : "paragraph",
+    text: lines.slice(span.start - 1, span.end)
+  };
+}
+
+// src/cite/core/adapt.ts
+function short(commit) {
+  return commit.slice(0, 7);
+}
+function plural(n, noun) {
+  return `${String(n)} ${noun}${n === 1 ? "" : "s"}`;
+}
+function citesEncrypted(src) {
+  try {
+    return parseSrc(src).encrypted;
+  } catch {
+    return false;
+  }
+}
+function missingMessage(source) {
+  if (!citesEncrypted(source.src)) return "missing";
+  switch (source.missingReason) {
+    case "no-key":
+      return "missing (no encryption key is available to decrypt it)";
+    case "undecryptable":
+      return "missing (does not decrypt under the current key)";
+    case "untracked":
+      return "missing (no tracked file matches; wrong --root?)";
+    case "unreadable":
+    case void 0:
+      return "missing";
+  }
+}
+function messageFor(source) {
+  switch (source.status) {
+    case "current":
+      return "current";
+    case "skipped":
+      return "skipped";
+    case "moved":
+      return `moved -> ${shortSrc(source.newSrc ?? "?")}`;
+    case "moved-ambiguous": {
+      const candidates = source.candidates ?? [];
+      return `moved, ${plural(candidates.length, "candidate")} (${candidates.map(shortSrc).join(", ")}); widen the range`;
+    }
+    case "changed": {
+      const span = source.newLines === void 0 ? "" : `; now at lines ${source.newLines}`;
+      if (source.commitSha === void 0) return `changed${span}`;
+      const at2 = short(source.commitSha);
+      if (source.historyAvailable === false) {
+        return `changed (history unavailable: commit ${at2} not found; fetch-depth: 0)`;
+      }
+      if (source.commitsSince === void 0) return `changed since ${at2}${span}`;
+      return `changed since ${at2}, ${plural(source.commitsSince.length, "commit")}${span}`;
+    }
+    case "never-true":
+      return source.commitSha === void 0 ? "never true: the pin does not match at the recorded commit" : `never true: the pin does not match at ${short(source.commitSha)}`;
+    case "missing":
+      return missingMessage(source);
+  }
+}
+function named(id, text) {
+  return id === void 0 ? text : `${id}: ${text}`;
+}
+function at(spec) {
+  return spec.includes("-") ? `lines ${spec}` : `line ${spec}`;
+}
+function claimMessageFor(result) {
+  const claim = result.claim;
+  const id = result.citation.id;
+  if (claim === null) return "";
+  const where = claim.fileLines ?? (result.markerLine === void 0 ? void 0 : String(result.markerLine));
+  switch (claim.status) {
+    case "moved":
+      return named(
+        id,
+        `the claim moved from ${at(where ?? "?")} to ${at(claim.newFileLines ?? "?")}.`
+      );
+    case "moved-ambiguous":
+      return named(
+        id,
+        `the claim at ${at(where ?? "?")} now appears at lines ${listOf(claim.candidateFileLines ?? [])}.`
+      );
+    case "reanchored": {
+      const since = claim.commitSha === void 0 ? "" : ` since ${short(claim.commitSha)}`;
+      const to = claim.newFileLines === void 0 ? "" : `, to ${at(claim.newFileLines)}`;
+      return named(
+        id,
+        `the claim at ${at(where ?? "?")} was reanchored${since}${to}. Its words are unchanged.`
+      );
+    }
+    case "changed":
+      if (where === void 0) {
+        return named(
+          id,
+          "the claim has no lines and no marker names the entry, so its pin anchors nothing."
+        );
+      }
+      return named(id, `the claim at ${at(where)} has ${claimChange(claim)}`);
+    case "current":
+    case "skipped":
+      return "";
+  }
+}
+function claimChange(claim) {
+  if (claim.historyAvailable === false) {
+    return "changed since it was pinned (history unavailable; fetch-depth: 0).";
+  }
+  if (claim.commitSha === void 0) return "changed since it was pinned.";
+  const at2 = short(claim.commitSha);
+  const since = claim.commitsSince ?? [];
+  const count = since.length === 0 ? "uncommitted" : plural(since.length, "commit");
+  return `changed since ${at2}, ${count}.`;
+}
+function misplacedMessageFor(id, marker) {
+  const place = marker.block ? `above the block at line ${String(marker.place)}` : `above line ${String(marker.place)}`;
+  return named(
+    id,
+    `the marker at line ${String(marker.line)} splits the paragraph at ${at(marker.unit)}. Its place is ${place}.`
+  );
+}
+function sourceRuleOf(status) {
+  if (status === "skipped" || status === "current") return void 0;
+  return `source-${status}`;
+}
+function claimRuleOf(claim) {
+  const status = claim.status;
+  if (status === "skipped" || status === "current") return void 0;
+  return `claim-${status}`;
+}
+function entrySite(result) {
+  const site = {};
+  if (result.origin.line !== void 0) site.line = result.origin.line;
+  if (result.origin.kind === "manifest") site.file = result.origin.file;
+  return site;
+}
+function anchorSite(result) {
+  if (result.anchorLine !== void 0) return { line: result.anchorLine };
+  return entrySite(result);
+}
+function findingsFor(results, severity) {
+  const out = [];
+  const push = (result, rule, message, site, extra) => {
+    const level = severity[rule];
+    if (level === "off") return;
+    const finding = {
+      rule,
+      ruleId: ruleId(rule),
+      severity: level,
+      message,
+      src: result.source.src,
+      index: result.origin.index
+    };
+    if (site.line !== void 0) finding.line = site.line;
+    if (site.file !== void 0) finding.file = site.file;
+    if (result.citation.id !== void 0) finding.id = result.citation.id;
+    if (extra?.newSrc !== void 0) finding.newSrc = extra.newSrc;
+    out.push(finding);
+  };
+  for (const result of results) {
+    const claim = result.claim;
+    if (claim !== null) {
+      const rule2 = claimRuleOf(claim);
+      if (rule2 !== void 0) {
+        const site = claimLine(claim) === void 0 && result.markerLine === void 0 ? entrySite(result) : { line: claimLine(claim) ?? result.markerLine };
+        push(result, rule2, claimMessageFor(result), site);
+      }
+    }
+    const rule = sourceRuleOf(result.source.status);
+    if (rule === void 0) continue;
+    const extra = result.source.newSrc === void 0 ? void 0 : { newSrc: result.source.newSrc };
+    push(result, rule, messageFor(result.source), anchorSite(result), extra);
+  }
+  return out;
+}
+function integrityFor(finding, results) {
+  if (finding.index === void 0) return void 0;
+  return results.find((r) => r.origin.index === finding.index)?.citation.source.integrity;
+}
+function errorSite(finding) {
+  if (finding.file === void 0) {
+    return finding.line === void 0 ? {} : { line: finding.line };
+  }
+  if (finding.file.startsWith("../") || isAbsolute(finding.file)) return {};
+  return {
+    file: finding.file,
+    ...finding.line === void 0 ? {} : { line: finding.line }
+  };
+}
+function toValidationResult(report) {
+  const errors = report.findings.map((finding) => {
+    const error = {
+      schema: RULE_ID_PREFIX,
+      instancePath: finding.index === void 0 ? "" : `/citations/${String(finding.index)}`,
+      message: finding.message,
+      keyword: finding.rule,
+      severity: finding.severity
+    };
+    const subject = finding.id ?? integrityFor(finding, report.citations);
+    if (subject !== void 0) error.subject = subject;
+    const site = errorSite(finding);
+    if (site.file !== void 0) error.file = site.file;
+    if (site.line !== void 0) error.line = site.line;
+    return error;
+  });
+  return {
+    file: report.file,
+    format: report.format,
+    ok: !errors.some(isErrorSeverity),
+    schemas: [RULE_ID_PREFIX],
+    errors
+  };
+}
+
+export {
+  isUnitText,
+  markerRunAt,
+  splitUnit,
+  pre43Span,
+  misplacedMarkerAt,
+  misplacedMarkers,
+  movedUnit,
+  unitText,
+  applyMarkerMoves,
+  markerClaimEnd,
+  normalizeWhitespace,
+  blockMatches,
+  claimLine,
+  claimLineNow,
+  claimLinesNow,
+  claimEnd,
+  otherClaimSpans,
+  spellElsewhere,
+  unitAt,
+  noUnitAt,
+  markerUnit,
+  shortPin,
+  shortCommit,
+  shortSrc,
+  shortLine,
+  spellAt,
+  listOf,
+  messageFor,
+  claimMessageFor,
+  misplacedMessageFor,
+  findingsFor,
+  errorSite,
+  toValidationResult
+};
+//# sourceMappingURL=chunk-252LNOEG.js.map