@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/chunk-CK7SKVHR.js

@@ -0,0 +1,1042 @@
+#!/usr/bin/env node
+import {
+  ToolError
+} from "./chunk-G3T47CFV.js";
+
+// src/lint/types.ts
+var LintError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "LintError";
+  }
+};
+
+// src/lint/rules/paragraphs.ts
+function checkParagraphsIn(content, rule, ctx) {
+  if (!rule) return [];
+  const paragraphs = paragraphsOf(content);
+  const findings = checkCount(
+    paragraphs.length,
+    rule,
+    "paragraph",
+    "paragraphs_count_error",
+    ctx
+  );
+  const pattern = rule.pattern;
+  if (pattern) {
+    const regex = compilePattern(pattern);
+    paragraphs.forEach((paragraph, index) => {
+      if (!regex.test(paragraph.text)) {
+        findings.push({
+          type: "paragraphs_pattern_error",
+          heading: ctx.heading,
+          message: `Paragraph ${index + 1} does not match /${pattern}/`,
+          position: paragraph.position,
+          severity: "error"
+        });
+      }
+    });
+  }
+  return findings;
+}
+
+// src/lint/rules/code-blocks.ts
+function checkCodeBlocksIn(content, rule, ctx) {
+  if (!rule) return [];
+  const codeBlocks = codeBlocksOf(content);
+  const counted = rule.fenceInfo ? codeBlocks.filter((block) => matchesFenceInfo(block, rule.fenceInfo)) : codeBlocks;
+  const findings = checkCount(
+    counted.length,
+    rule,
+    "code block",
+    "code_blocks_count_error",
+    ctx
+  );
+  if (rule.language) {
+    findings.push(...checkLanguages(codeBlocks, rule.language, ctx));
+  }
+  return findings;
+}
+function matchesFenceInfo(block, pattern) {
+  return compilePattern(pattern).test(block.fenceInfo ?? "");
+}
+function checkLanguages(codeBlocks, language, ctx) {
+  const languages = Array.isArray(language) ? language : [language];
+  const only = languages[0];
+  if (languages.length === 0 || only === void 0) return [];
+  const label = languages.length === 1 ? `"${only}"` : `one of ${languages.map((lang) => `"${lang}"`).join(", ")}`;
+  const findings = [];
+  codeBlocks.forEach((block, index) => {
+    if (block.language !== void 0 && languages.includes(block.language)) return;
+    const found = block.language ? `but found "${block.language}"` : "but found no language";
+    findings.push({
+      type: "code_blocks_language_error",
+      heading: ctx.heading,
+      message: `Expected code block ${index + 1} to declare ${label}, ${found}`,
+      position: block.position,
+      severity: "error"
+    });
+  });
+  return findings;
+}
+
+// src/lint/rules/tables.ts
+function checkTablesIn(content, rule, ctx) {
+  if (!rule) return [];
+  const tables = tablesOf(content);
+  const findings = checkCount(tables.length, rule, "table", "tables_count_error", ctx);
+  if (rule.columns) {
+    for (const table of tables) {
+      const actual = headerCells(table);
+      if (!sameColumns(actual, rule.columns)) {
+        findings.push({
+          type: "tables_columns_error",
+          heading: ctx.heading,
+          message: `Expected table columns ${quoteList(rule.columns)}, but found ${quoteList(actual)}`,
+          position: table.position,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return findings;
+}
+function headerCells(table) {
+  const header = table.children.find((row) => row.header);
+  return header ? header.children.map((cell) => cell.text) : [];
+}
+function sameColumns(actual, expected) {
+  return actual.length === expected.length && actual.every((cell, index) => cell === expected[index]);
+}
+
+// src/lint/rules/admonitions.ts
+function checkAdmonitionsIn(content, rule, ctx) {
+  if (!rule) return [];
+  const admonitions = admonitionsOf(content);
+  const findings = checkCount(
+    admonitions.length,
+    rule,
+    "admonition",
+    "admonitions_count_error",
+    ctx
+  );
+  if (rule.variant) {
+    findings.push(...checkVariant(admonitions, rule.variant, ctx));
+  }
+  return findings;
+}
+function checkVariant(admonitions, variant, ctx) {
+  const findings = [];
+  for (const admonition of admonitions) {
+    if (admonition.variant !== variant) {
+      const found = admonition.variant ? `but found a ${admonition.variant}` : "but found one with no type";
+      findings.push({
+        type: "admonitions_variant_error",
+        heading: ctx.heading,
+        message: `Expected a ${variant} admonition, ${found}`,
+        position: admonition.position,
+        severity: "error"
+      });
+    }
+  }
+  return findings;
+}
+
+// src/lint/rules/images.ts
+function checkImagesIn(content, rule, ctx) {
+  if (!rule) return [];
+  const matching = imagesOf(content).filter((image) => matches(image, rule));
+  return checkCount(matching.length, rule, "image", "images_count_error", ctx);
+}
+function matches(image, rule) {
+  if (rule.url !== void 0 && image.url !== rule.url) return false;
+  if (rule.alt !== void 0 && image.alt !== rule.alt) return false;
+  if (rule.attributes && Object.keys(rule.attributes).length > 0) return false;
+  return true;
+}
+
+// src/lint/rules/blockquotes.ts
+function checkBlockquotesIn(content, rule, ctx) {
+  if (!rule) return [];
+  return checkCount(blockquotesOf(content).length, rule, "blockquote", "blockquotes_count_error", ctx);
+}
+
+// src/lint/rules/definition-lists.ts
+function checkDefinitionListsIn(content, rule, ctx) {
+  if (!rule) return [];
+  return checkCount(
+    definitionListsOf(content).length,
+    rule,
+    "definition list",
+    "definition_lists_count_error",
+    ctx
+  );
+}
+
+// src/lint/rules/sequence.ts
+function groupRuns(content) {
+  const runs = [];
+  for (const node of content) {
+    const current = runs[runs.length - 1];
+    if (current && current.kind === node.kind) {
+      current.nodes.push(node);
+      current.position = {
+        start: current.position.start,
+        end: node.position.end
+      };
+    } else {
+      runs.push({
+        kind: node.kind,
+        nodes: [node],
+        position: { start: node.position.start, end: node.position.end }
+      });
+    }
+  }
+  return runs;
+}
+var KIND_OF_BLOCK = {
+  paragraphs: "paragraph",
+  codeBlocks: "codeBlock",
+  lists: "list",
+  tables: "table",
+  admonitions: "admonition",
+  images: "image",
+  blockquotes: "blockquote",
+  definitionLists: "definitionList",
+  elements: "element"
+};
+function sequenceLabel(kind) {
+  switch (kind) {
+    case "paragraph":
+      return "paragraph";
+    case "codeBlock":
+      return "code";
+    case "list":
+      return "list";
+    case "table":
+      return "table";
+    case "admonition":
+      return "admonition";
+    case "image":
+      return "image";
+    case "blockquote":
+      return "blockquote";
+    case "definitionList":
+      return "definition list";
+    case "element":
+      return "element";
+    default:
+      return kind;
+  }
+}
+function keyOf(entry) {
+  for (const kind of BLOCK_KINDS) {
+    if (entry[kind] !== void 0) return kind;
+  }
+  return null;
+}
+function checkSequence(section, rule) {
+  return checkSequenceIn(section.children, rule, sectionContext(section));
+}
+function checkSequenceIn(content, rule, ctx) {
+  if (!rule) return [];
+  const runs = groupRuns(content);
+  const expectedKinds = rule.map((entry) => {
+    const key = keyOf(entry);
+    return key ? KIND_OF_BLOCK[key] : null;
+  });
+  const actualKinds = runs.map((run) => run.kind);
+  const matches2 = expectedKinds.length === actualKinds.length && expectedKinds.every((kind, index) => kind === actualKinds[index]);
+  if (!matches2) {
+    const expected = expectedKinds.map((kind) => kind ? sequenceLabel(kind) : "?");
+    const found = actualKinds.length > 0 ? actualKinds.map(sequenceLabel) : ["nothing"];
+    return [
+      {
+        type: "content_order_error",
+        heading: ctx.heading,
+        message: `Expected ${expected.join(" then ")}, but found ${found.join(" then ")}`,
+        position: ctx.position,
+        severity: "error"
+      }
+    ];
+  }
+  const findings = [];
+  runs.forEach((run, index) => {
+    const entry = rule[index];
+    if (!entry) return;
+    const runCtx = { heading: ctx.heading, position: run.position };
+    findings.push(...checkContainsIn(run.nodes, entry, runCtx));
+  });
+  return findings;
+}
+
+// src/lint/rules/elements.ts
+function checkElementsIn(content, rule, ctx) {
+  if (!rule) return [];
+  const tags = rule.tag === void 0 ? void 0 : Array.isArray(rule.tag) ? rule.tag : [rule.tag];
+  const matching = tags ? elementsOf(content).filter((element) => tags.includes(element.name)) : elementsOf(content);
+  const noun = tags ? `${tags.map((tag) => `"${tag}"`).join(" or ")} element` : "element";
+  const findings = checkCount(matching.length, rule, noun, "elements_count_error", ctx);
+  if (rule.attributes) {
+    for (const element of matching) {
+      findings.push(...checkAttributes(element, rule.attributes, ctx));
+    }
+  }
+  if (rule.sequence || rule.contains) {
+    for (const element of matching) {
+      const elementCtx = { heading: ctx.heading, position: element.position };
+      findings.push(...checkSequenceIn(element.children, rule.sequence, elementCtx));
+      findings.push(...checkContainsIn(element.children, rule.contains, elementCtx));
+    }
+  }
+  return findings;
+}
+function checkAttributes(element, rule, ctx) {
+  const findings = [];
+  for (const [key, expected] of Object.entries(rule)) {
+    const finding = checkOne(element, key, expected, ctx);
+    if (finding) findings.push(finding);
+  }
+  return findings;
+}
+function checkOne(element, key, expected, ctx) {
+  const attributes = element.attributes ?? {};
+  const present = key in attributes;
+  const actual = attributes[key];
+  const fail = (want, detail) => ({
+    type: "elements_attribute_error",
+    heading: ctx.heading,
+    message: `Expected the "${element.name}" element ${want}, but ${detail}`,
+    position: element.position,
+    severity: "error"
+  });
+  if (expected === false) {
+    if (!present) return null;
+    const found = actual === true ? `an expression` : `${key}="${String(actual)}"`;
+    return fail(`not to carry ${key}`, `found ${found}`);
+  }
+  if (!present) return fail(attributeWant(key, expected), `it carries no ${key}`);
+  if (expected === true) return null;
+  if (actual === true) return fail(attributeWant(key, expected), `its ${key} is an expression`);
+  if (actual !== expected) return fail(attributeWant(key, expected), `found ${key}="${String(actual)}"`);
+  return null;
+}
+function attributeWant(key, expected) {
+  return expected === true ? `to carry ${key}` : `to carry ${key}="${expected}"`;
+}
+
+// src/lint/rules/contains.ts
+function checkContains(section, rule) {
+  return checkContainsIn(section.children, rule, sectionContext(section));
+}
+function checkContainsIn(content, rule, ctx) {
+  if (!rule) return [];
+  const findings = [];
+  for (const kind of BLOCK_KINDS) {
+    switch (kind) {
+      case "paragraphs":
+        findings.push(...checkParagraphsIn(content, rule.paragraphs, ctx));
+        break;
+      case "codeBlocks":
+        findings.push(...checkCodeBlocksIn(content, rule.codeBlocks, ctx));
+        break;
+      case "lists":
+        findings.push(...checkListsIn(content, rule.lists, ctx));
+        break;
+      case "tables":
+        findings.push(...checkTablesIn(content, rule.tables, ctx));
+        break;
+      case "admonitions":
+        findings.push(...checkAdmonitionsIn(content, rule.admonitions, ctx));
+        break;
+      case "images":
+        findings.push(...checkImagesIn(content, rule.images, ctx));
+        break;
+      case "blockquotes":
+        findings.push(...checkBlockquotesIn(content, rule.blockquotes, ctx));
+        break;
+      case "definitionLists":
+        findings.push(...checkDefinitionListsIn(content, rule.definitionLists, ctx));
+        break;
+      case "elements":
+        findings.push(...checkElementsIn(content, rule.elements, ctx));
+        break;
+    }
+  }
+  return findings;
+}
+
+// src/lint/rules/lists.ts
+function checkListsIn(content, rule, ctx) {
+  if (!rule) return [];
+  const lists = listsOf(content);
+  const findings = checkCount(lists.length, rule, "list", "lists_count_error", ctx);
+  if (rule.ordered !== void 0) {
+    findings.push(...checkOrdered(lists, rule.ordered, ctx));
+  }
+  const items = rule.items;
+  if (!items) return findings;
+  findings.push(...checkItemCounts(lists, items, ctx));
+  if (!items.sequence && !items.contains) return findings;
+  for (const list of lists) {
+    for (const item of list.items) {
+      const itemCtx = { heading: ctx.heading, position: item.position };
+      if (items.sequence) {
+        findings.push(...checkSequenceIn(item.children, items.sequence, itemCtx));
+      } else if (items.contains) {
+        findings.push(...checkContainsIn(item.children, items.contains, itemCtx));
+      }
+    }
+  }
+  return findings;
+}
+function checkOrdered(lists, ordered, ctx) {
+  const findings = [];
+  for (const list of lists) {
+    if (list.ordered !== ordered) {
+      findings.push({
+        type: "lists_ordered_error",
+        heading: ctx.heading,
+        message: ordered ? "Expected a numbered list, but found a bulleted list" : "Expected a bulleted list, but found a numbered list",
+        position: list.position,
+        severity: "error"
+      });
+    }
+  }
+  return findings;
+}
+function checkItemCounts(lists, items, ctx) {
+  const findings = [];
+  const min = items.min ?? (items.max === 0 ? 0 : 1);
+  const max = items.max ?? null;
+  if (max !== null) {
+    const offender = lists.find((list) => list.items.length > max);
+    if (offender) {
+      findings.push({
+        type: "lists_items_count_error",
+        heading: ctx.heading,
+        message: `Expected at most ${max} items in a list, but found ${offender.items.length}`,
+        position: offender.position,
+        severity: "error"
+      });
+    }
+  }
+  if (min > 0) {
+    const offender = lists.find((list) => list.items.length < min);
+    if (offender) {
+      findings.push({
+        type: "lists_items_count_error",
+        heading: ctx.heading,
+        message: `Expected at least ${min} items in a list, but found ${offender.items.length}`,
+        position: offender.position,
+        severity: "error"
+      });
+    }
+  }
+  return findings;
+}
+
+// src/lint/rules/index.ts
+var BLOCK_KINDS = [
+  "paragraphs",
+  "codeBlocks",
+  "lists",
+  "tables",
+  "admonitions",
+  "images",
+  "blockquotes",
+  "definitionLists",
+  "elements"
+];
+function sectionContext(section) {
+  return { heading: section.title || null, position: section.position };
+}
+function paragraphsOf(content) {
+  return content.filter((node) => node.kind === "paragraph");
+}
+function codeBlocksOf(content) {
+  return content.filter((node) => node.kind === "codeBlock");
+}
+function listsOf(content) {
+  return content.filter((node) => node.kind === "list");
+}
+function tablesOf(content) {
+  return content.filter((node) => node.kind === "table");
+}
+function admonitionsOf(content) {
+  return content.filter((node) => node.kind === "admonition");
+}
+function imagesOf(content) {
+  return content.filter((node) => node.kind === "image");
+}
+function blockquotesOf(content) {
+  return content.filter((node) => node.kind === "blockquote");
+}
+function definitionListsOf(content) {
+  return content.filter((node) => node.kind === "definitionList");
+}
+function elementsOf(content) {
+  return content.filter((node) => node.kind === "element");
+}
+function plural(noun, count) {
+  return count === 1 ? noun : `${noun}s`;
+}
+function quoteList(items) {
+  return items.map((item) => `"${item}"`).join(", ");
+}
+function checkCount(count, rule, noun, type, ctx) {
+  const findings = [];
+  const min = rule.min ?? (rule.max === 0 ? 0 : 1);
+  const max = rule.max ?? null;
+  if (count < min) {
+    findings.push({
+      type,
+      heading: ctx.heading,
+      message: `Expected at least ${min} ${plural(noun, min)}, but found ${count}`,
+      position: ctx.position,
+      severity: "error"
+    });
+  }
+  if (max !== null && count > max) {
+    findings.push({
+      type,
+      heading: ctx.heading,
+      message: `Expected at most ${max} ${plural(noun, max)}, but found ${count}`,
+      position: ctx.position,
+      severity: "error"
+    });
+  }
+  return findings;
+}
+var compiled = /* @__PURE__ */ new Map();
+function compilePattern(pattern) {
+  const hit = compiled.get(pattern);
+  if (hit) return hit;
+  try {
+    const regex = new RegExp(pattern);
+    compiled.set(pattern, regex);
+    return regex;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new LintError(`Invalid pattern "${pattern}": ${reason}`);
+  }
+}
+function clearPatternCache() {
+  compiled.clear();
+}
+
+// src/lint/rules/heading.ts
+function ownTitle(section) {
+  return section.titlePosition === null ? null : section.title;
+}
+function checkHeading(section, rule) {
+  if (rule === void 0) return [];
+  const position = section.titlePosition ?? section.position;
+  const title = ownTitle(section);
+  const found = title === null ? "no heading" : `"${title}"`;
+  const fail = (message) => [
+    {
+      type: "heading_error",
+      // `|| null`, as `sectionContext` and `match.ts`'s `anchor` both do. A
+      // headless section's title is `""`, and the JSON reporter's `heading` is
+      // a wire key `manni docevals` parses rather than validates, so two
+      // spellings of "no heading" would reach it as two different facts.
+      heading: section.title || null,
+      message,
+      position,
+      severity: "error"
+    }
+  ];
+  if (rule === false) {
+    return title === null ? [] : fail(`Expected no heading of its own, but found ${found}`);
+  }
+  if (typeof rule === "string") {
+    return title === rule ? [] : fail(`Expected title "${rule}", but found ${found}`);
+  }
+  if (Array.isArray(rule)) {
+    if (title !== null && rule.includes(title)) return [];
+    return fail(`Expected one of ${rule.map((option) => `"${option}"`).join(", ")}, but found ${found}`);
+  }
+  if (title !== null && compilePattern(rule.pattern).test(title)) return [];
+  return fail(`Expected title matching /${rule.pattern}/, but found ${found}`);
+}
+
+// src/lint/core/template.ts
+var BLOCK_KINDS2 = [
+  "paragraphs",
+  "codeBlocks",
+  "lists",
+  "tables",
+  "admonitions",
+  "images",
+  "blockquotes",
+  "definitionLists",
+  "elements"
+];
+var BLOCK_KIND_NODE = {
+  paragraphs: "paragraph",
+  codeBlocks: "codeBlock",
+  lists: "list",
+  tables: "table",
+  admonitions: "admonition",
+  images: "image",
+  blockquotes: "blockquote",
+  definitionLists: "definitionList",
+  elements: "element"
+};
+function isWildcard(rule) {
+  return rule.heading === void 0;
+}
+function occurrenceRange(rule) {
+  return { min: rule.min ?? (rule.max === 0 ? 0 : 1), max: rule.max ?? null };
+}
+function headingMatches(heading, title) {
+  if (heading === void 0) return true;
+  if (heading === false) return title === null;
+  if (title === null) return false;
+  if (typeof heading === "string") return title === heading;
+  if (Array.isArray(heading)) return heading.includes(title);
+  return compilePattern(heading.pattern).test(title);
+}
+
+// src/lint/core/match.ts
+var ALIGNMENT_COSTS = {
+  match: 0,
+  coerce: 1,
+  skipRule: 2,
+  skipSection: 2
+};
+var STATE_LIMIT = 2e3;
+var RANK = {
+  match: 0,
+  structure: 0,
+  coerce: 1,
+  skipRule: 2,
+  skipSection: 3
+};
+var NO_EPS = [];
+function expandedStates(rules) {
+  let total = 1;
+  for (const rule of rules) total += ruleStates(rule);
+  return total;
+}
+function ruleStates(rule) {
+  let unit = 1;
+  if (rule.repeat) {
+    unit = 0;
+    for (const member of rule.repeat) unit += ruleStates(member);
+  }
+  const { min, max } = occurrenceRange(rule);
+  if (max === null) return unit * (Math.max(min, 0) + 1) + 2;
+  return unit * Math.max(0, max);
+}
+function listAt(lists, index) {
+  const list = lists[index];
+  if (list) return list;
+  const created = [];
+  lists[index] = created;
+  return created;
+}
+function compile(rules) {
+  const consume = [];
+  const consumeTo = [];
+  const epsOut = [];
+  const epsIn = [];
+  const inRepeat = [];
+  const newState = () => {
+    consume.push(null);
+    consumeTo.push(-1);
+    epsOut.push([]);
+    epsIn.push([]);
+    inRepeat.push(false);
+    return consume.length - 1;
+  };
+  const eps = (from, to, cost, rank, occ) => {
+    const edge = { from, to, cost, rank, occ };
+    listAt(epsOut, from).push(edge);
+    listAt(epsIn, to).push(edge);
+  };
+  const leaf = (from, occ) => {
+    const to = newState();
+    consume[from] = occ;
+    consumeTo[from] = to;
+    eps(from, to, occ.required ? ALIGNMENT_COSTS.skipRule : 0, RANK.skipRule, occ);
+    return to;
+  };
+  const buildCopy = (rule, from, groups, required) => {
+    if (rule.repeat) {
+      const copy = { rule, members: [] };
+      const nested = [...groups, copy];
+      let cursor2 = from;
+      for (const member of rule.repeat) {
+        cursor2 = buildRule(member, cursor2, nested, required);
+      }
+      return cursor2;
+    }
+    const { max } = occurrenceRange(rule);
+    const occ = {
+      rule,
+      required,
+      coercible: required && max === 1,
+      wildcard: isWildcard(rule),
+      groups
+    };
+    for (const group of groups) group.members.push(occ);
+    return leaf(from, occ);
+  };
+  function buildRule(rule, from, groups, context) {
+    const { min, max } = occurrenceRange(rule);
+    const floor = max === null ? Math.max(min, 0) : Math.min(Math.max(min, 0), max);
+    const copies = max === null ? floor : Math.max(0, max);
+    const first = consume.length;
+    let cursor2 = from;
+    for (let copy = 0; copy < copies; copy++) {
+      cursor2 = buildCopy(rule, cursor2, groups, context && copy < floor);
+    }
+    let end = cursor2;
+    if (max === null) {
+      const loop = newState();
+      eps(cursor2, loop, 0, RANK.structure, null);
+      const back = buildCopy(rule, loop, groups, false);
+      eps(back, loop, 0, RANK.structure, null);
+      end = newState();
+      eps(loop, end, 0, RANK.structure, null);
+    }
+    if (copies > 1 || max === null) {
+      for (let state = first; state < consume.length; state++) {
+        if (state !== end) inRepeat[state] = true;
+      }
+    }
+    return end;
+  }
+  const start = newState();
+  let cursor = start;
+  for (const rule of rules) cursor = buildRule(rule, cursor, [], true);
+  return {
+    states: consume.length,
+    start,
+    accept: cursor,
+    consume,
+    consumeTo,
+    epsOut,
+    epsIn,
+    inRepeat
+  };
+}
+var compiled2 = /* @__PURE__ */ new WeakMap();
+function automatonFor(rules, options) {
+  const hit = compiled2.get(rules);
+  if (hit) return hit;
+  const states = expandedStates(rules);
+  if (states > STATE_LIMIT) {
+    const source = options.source ?? "template";
+    const label = options.template != null ? `${source}#${options.template}` : `${source}: the rule list`;
+    throw new LintError(
+      `${label} expands to ${states} states; the limit is ${STATE_LIMIT}. Cap a max, or split the template.`
+    );
+  }
+  const built = compile(rules);
+  compiled2.set(rules, built);
+  return built;
+}
+function titleOf(section) {
+  return section.titlePosition === null ? null : section.title;
+}
+var Heap = class {
+  costs = [];
+  items = [];
+  get size() {
+    return this.items.length;
+  }
+  /*
+   * Every `?? 0` in this class is unreachable, and is here only because
+   * `noUncheckedIndexedAccess` cannot see the bounds the arithmetic already
+   * guarantees. `costs` and `items` are pushed and popped together and so
+   * always have the same length; `child` is the index just pushed, and
+   * `parent = (child - 1) >> 1` is in bounds whenever `child > 0`; `left` and
+   * `right` are compared against `length` before they are read.
+   *
+   * Worth stating rather than leaving to inference: were an index ever out of
+   * bounds, the fallback would read as cost 0, quietly inverting the heap
+   * order rather than throwing. It is a type-checker concession, not a
+   * defensive default.
+   */
+  push(cost, item) {
+    this.costs.push(cost);
+    this.items.push(item);
+    let child = this.items.length - 1;
+    while (child > 0) {
+      const parent = child - 1 >> 1;
+      if ((this.costs[parent] ?? 0) <= (this.costs[child] ?? 0)) break;
+      this.swap(parent, child);
+      child = parent;
+    }
+  }
+  pop() {
+    const cost = this.costs[0] ?? 0;
+    const item = this.items[0] ?? 0;
+    const lastCost = this.costs.pop();
+    const lastItem = this.items.pop();
+    if (this.items.length > 0 && lastCost !== void 0 && lastItem !== void 0) {
+      this.costs[0] = lastCost;
+      this.items[0] = lastItem;
+      let parent = 0;
+      for (; ; ) {
+        const left = parent * 2 + 1;
+        const right = left + 1;
+        let smallest = parent;
+        if (left < this.items.length && (this.costs[left] ?? 0) < (this.costs[smallest] ?? 0)) {
+          smallest = left;
+        }
+        if (right < this.items.length && (this.costs[right] ?? 0) < (this.costs[smallest] ?? 0)) {
+          smallest = right;
+        }
+        if (smallest === parent) break;
+        this.swap(parent, smallest);
+        parent = smallest;
+      }
+    }
+    return { cost, item };
+  }
+  swap(a, b) {
+    const cost = this.costs[a] ?? 0;
+    const item = this.items[a] ?? 0;
+    this.costs[a] = this.costs[b] ?? 0;
+    this.items[a] = this.items[b] ?? 0;
+    this.costs[b] = cost;
+    this.items[b] = item;
+  }
+};
+function align(sections, nfa) {
+  const n = sections.length;
+  const states = nfa.states;
+  const radix = 2 * (n + states) + 2;
+  const weigh = (primary, wildcards, brokenRuns) => (primary * radix + wildcards) * radix + brokenRuns;
+  const SKIP_SECTION = weigh(ALIGNMENT_COSTS.skipSection, 0, 0);
+  const SKIP_SECTION_IN_RUN = weigh(ALIGNMENT_COSTS.skipSection, 0, 1);
+  const MATCH = weigh(ALIGNMENT_COSTS.match, 0, 0);
+  const MATCH_WILDCARD = weigh(ALIGNMENT_COSTS.match, 1, 0);
+  const COERCE = weigh(ALIGNMENT_COSTS.coerce, 0, 0);
+  const consumeCost = (state2, index2) => {
+    const occ = nfa.consume[state2];
+    const section = sections[index2];
+    const to = nfa.consumeTo[state2];
+    if (!occ || !section || to === void 0 || to < 0) return null;
+    if (headingMatches(occ.rule.heading, titleOf(section))) {
+      const cost = occ.wildcard ? MATCH_WILDCARD : MATCH;
+      return { cost, rank: RANK.match, to, occ };
+    }
+    if (occ.coercible) return { cost: COERCE, rank: RANK.coerce, to, occ };
+    return null;
+  };
+  const skipSectionCost = (state2) => nfa.inRepeat[state2] === true ? SKIP_SECTION_IN_RUN : SKIP_SECTION;
+  const dist = new Float64Array((n + 1) * states).fill(Infinity);
+  const distAt = (slot) => dist[slot] ?? Infinity;
+  for (let index2 = n; index2 >= 0; index2--) {
+    const base = index2 * states;
+    const next = base + states;
+    const heap = new Heap();
+    for (let state2 = 0; state2 < states; state2++) {
+      let best = Infinity;
+      if (index2 === n) {
+        if (state2 === nfa.accept) best = 0;
+      } else {
+        const step = consumeCost(state2, index2);
+        if (step) best = step.cost + distAt(next + step.to);
+        const skipped = skipSectionCost(state2) + distAt(next + state2);
+        if (skipped < best) best = skipped;
+      }
+      dist[base + state2] = best;
+      if (best < Infinity) heap.push(best, state2);
+    }
+    const done = new Uint8Array(states);
+    while (heap.size > 0) {
+      const { cost, item } = heap.pop();
+      if (done[item] === 1 || cost > distAt(base + item)) continue;
+      done[item] = 1;
+      for (const edge of nfa.epsIn[item] ?? NO_EPS) {
+        const candidate = cost + edge.cost;
+        if (candidate < distAt(base + edge.from)) {
+          dist[base + edge.from] = candidate;
+          heap.push(candidate, edge.from);
+        }
+      }
+    }
+  }
+  if (distAt(nfa.start) === Infinity) {
+    throw new LintError("internal: no alignment exists for this rule list.");
+  }
+  const steps = [];
+  let index = 0;
+  let state = nfa.start;
+  let seen = /* @__PURE__ */ new Set([state]);
+  while (!(index === n && state === nfa.accept)) {
+    const moves = [];
+    const offer = (cost, rank, to, column, kind, occ) => {
+      const total = cost + distAt(column * states + to);
+      if (total === Infinity) return;
+      moves.push({ kind, to, column, occ, total, rank });
+    };
+    if (index < n) {
+      const step = consumeCost(state, index);
+      if (step) {
+        offer(
+          step.cost,
+          step.rank,
+          step.to,
+          index + 1,
+          step.rank === RANK.coerce ? "coerce" : "match",
+          step.occ
+        );
+      }
+      offer(skipSectionCost(state), RANK.skipSection, state, index + 1, "skip-section", null);
+    }
+    for (const edge of nfa.epsOut[state] ?? NO_EPS) {
+      if (seen.has(edge.to)) continue;
+      offer(edge.cost, edge.rank, edge.to, index, "skip-rule", edge.occ);
+    }
+    let move;
+    for (const candidate of moves) {
+      if (move === void 0 || candidate.total < move.total || candidate.total === move.total && candidate.rank < move.rank || candidate.total === move.total && candidate.rank === move.rank && candidate.to < move.to) {
+        move = candidate;
+      }
+    }
+    if (move === void 0) {
+      throw new LintError("internal: the alignment could not be reconstructed.");
+    }
+    if (move.kind !== "skip-rule" || move.occ !== null) {
+      steps.push({ kind: move.kind, index, occ: move.occ });
+    }
+    if (move.column !== index) {
+      index = move.column;
+      seen = /* @__PURE__ */ new Set();
+    }
+    state = move.to;
+    seen.add(state);
+  }
+  return steps;
+}
+function collapse(point) {
+  return { start: { ...point }, end: { ...point } };
+}
+function anchor(index, sections, parent) {
+  const section = sections[index];
+  if (section) {
+    return { heading: section.title || null, position: section.position };
+  }
+  if (parent) {
+    return { heading: parent.title || null, position: collapse(parent.position.end) };
+  }
+  const last = sections[sections.length - 1];
+  if (last) return { heading: null, position: collapse(last.position.end) };
+  return { heading: null, position: collapse({ line: 1, column: 1, offset: 0 }) };
+}
+function describeHeading(rule) {
+  const heading = rule.heading;
+  if (typeof heading === "string") return `"${heading}"`;
+  if (Array.isArray(heading)) return heading.map((text) => `"${text}"`).join(", ");
+  if (heading === false) return "a section with no heading";
+  if (heading !== void 0) return `/${heading.pattern}/`;
+  return rule.id === void 0 ? "any section" : `"${rule.id}"`;
+}
+function missingMessage(rule) {
+  const heading = rule.heading;
+  if (typeof heading === "string") return `Missing section "${heading}"`;
+  if (Array.isArray(heading)) {
+    return `Missing one of ${heading.map((text) => `"${text}"`).join(", ")}`;
+  }
+  if (heading === false) return "Missing section without a heading";
+  if (heading !== void 0) return `Missing section matching /${heading.pattern}/`;
+  return rule.id === void 0 ? "Missing section" : `Missing section "${rule.id}"`;
+}
+function missingGroupMessage(copy) {
+  const members = (copy.rule.repeat ?? []).map(describeHeading).join(" followed by ");
+  const name = copy.rule.id === void 0 ? "" : ` "${copy.rule.id}"`;
+  return `Missing group${name}: expected ${members}`;
+}
+function unexpectedMessage(section) {
+  const what = section.titlePosition === null ? "Unexpected section without a heading" : `Unexpected section "${section.title}"`;
+  return `${what}. Add a trailing rule with min: 0 to allow sections the template does not describe.`;
+}
+function matchSections(sections, rules, options = {}) {
+  const matches2 = [];
+  const findings = [];
+  if (!rules) return { matches: matches2, findings };
+  const parent = options.parent ?? null;
+  const nfa = automatonFor(rules, options);
+  const steps = align(sections, nfa);
+  const taken = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if ((step.kind === "match" || step.kind === "coerce") && step.occ) {
+      taken.add(step.occ);
+    }
+  }
+  const absentGroup = (occ) => {
+    for (const group of occ.groups) {
+      if (group.members.every((member) => !taken.has(member))) return group;
+    }
+    return null;
+  };
+  const reported = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    const section = sections[step.index];
+    if ((step.kind === "match" || step.kind === "coerce") && step.occ && section) {
+      matches2.push({
+        rule: step.occ.rule,
+        section,
+        coerced: step.kind === "coerce"
+      });
+      continue;
+    }
+    if (step.kind === "skip-section" && section) {
+      findings.push({
+        type: "unexpected_section",
+        heading: section.title || null,
+        message: unexpectedMessage(section),
+        position: section.position,
+        severity: "error"
+      });
+      continue;
+    }
+    if (step.kind !== "skip-rule" || !step.occ || !step.occ.required) continue;
+    const where = anchor(step.index, sections, parent);
+    const group = absentGroup(step.occ);
+    if (group) {
+      if (reported.has(group)) continue;
+      reported.add(group);
+      findings.push({
+        type: "missing_group",
+        heading: where.heading,
+        message: missingGroupMessage(group),
+        position: where.position,
+        severity: "error"
+      });
+      continue;
+    }
+    findings.push({
+      type: "missing_section",
+      heading: where.heading,
+      message: missingMessage(step.occ.rule),
+      position: where.position,
+      severity: "error"
+    });
+  }
+  return { matches: matches2, findings };
+}
+
+export {
+  LintError,
+  checkHeading,
+  checkSequence,
+  checkSequenceIn,
+  checkContains,
+  checkContainsIn,
+  clearPatternCache,
+  BLOCK_KINDS2 as BLOCK_KINDS,
+  BLOCK_KIND_NODE,
+  isWildcard,
+  occurrenceRange,
+  headingMatches,
+  matchSections
+};
+//# sourceMappingURL=chunk-CK7SKVHR.js.map