@openpresentation/opf 0.26.9 → 0.27.0

package/README.md

@@ -64,6 +64,8 @@ const { files } = await opf.convert(deck, { format: "pptx" }); // bytes, nothing
 
 Drawing and PowerPoint go through the optional peers `@openpresentation/opf-render` and `@openpresentation/opf-pptx`, which core loads the first time a call needs them; npm does not install them for you. The root has conditional exports (OPF 0.18 removed `/node`): `node`, `bun` and `deno` get this full build, and `browser`, `worker`, `workerd` and `default` get a browser-safe build with the same names and the same types, where `open`, `save` and `convert` reject with `OPFApiError` code `node-only`. Every other subpath runs in a browser. `parseSlideSelection(3 | "1-3" | [1, 3], total)` reads slide selections in both. See [OPF files in Node](../../docs/node.md).
 
+On Cloudflare Workers, Vercel Edge and other hosts that refuse code generation from strings, `validate` runs validators compiled at build time instead of compiling the schemas with Ajv. The `workerd`, `worker` and `edge-light` conditions choose them, so a Worker needs no alias and no option; code bundled for Node that runs on a worker (and a page under a strict Content-Security-Policy) imports `@openpresentation/opf/precompiled` once. The verdicts and findings are the same, and a CI lane runs the package in the real `workerd` runtime. See [Edge runtimes](../../docs/node.md#edge-runtimes-validators-that-never-compile-code).
+
 Use focused imports when you only need one surface:
 
 ```ts
@@ -111,6 +113,10 @@ Two browser-safe subpaths for source editors, the CLI and agents. `@openpresenta
 
 Added in 0.12.0 (not in 0.11.4 or earlier): `@openpresentation/opf/patch` is the one RFC 6902 implementation the CLI and the editor share (`applyPatch`, `applyPatchWithInverse`, `invertPatch`, strict pointer helpers, optional schema validation of the result); `@openpresentation/opf/diff` has `diff` (slide matching by id, content and similarity, moves, a readable report and a JSON Patch) and `merge` (three-way merge with conflict objects that never drop a side); `@openpresentation/opf/format` has `format` (canonical key order and layout, idempotent). See [the guide](../../docs/patch-diff-merge-format.md).
 
+### Ids, document hash and patch scope (CE-04, CE-05)
+
+`@openpresentation/opf/ids` (all of it also on the package root, the pointer and hash parts also on `/patch`) makes edits addressable and checkable. `assignIds(document, { generate? })` fills the missing `id` of slides and content payloads deterministically (`{ document, patch, assigned }`; existing ids are never changed). In an array, the pointer token `@intro` names the element whose `id` is `intro`, so `/slides/@intro/blocks/@kpi/text` survives reordering: `applyPatch` and `readPointer` resolve it, `resolveIdPointer` and `toIdPointer` convert a pointer, `resolveIdPatch` and `toIdPatch` a whole patch. `documentHash(document)` is `sha256:` and a SHA-256 of the key-sorted JSON (pure JavaScript, the same in Node, browsers and edge runtimes); `applyPatch(document, patch, { expectHash })` and `edit(deck, patch, { expectHash })` apply only to the document that hash was taken from, else throw `OPFPatchHashError` and change nothing. `touches(patch, document?)` returns the pointers (index and id form), ids, slide ids and kinds a patch reads and writes, for conflict detection and permission checks. See [the guide](../../docs/patch-diff-merge-format.md#ids-id-addressed-paths-hashes-and-patch-scope).
+
 ### Layout previews
 
 `@openpresentation/gallery/previews` ships pre-rendered SVG thumbnails for the

package/dist/browser.js

@@ -1,23 +1,26 @@
-import { OPFApiError } from './chunk-D25BNPTW.js';
-export { OPFApiError, OPFExportError, OPFImportError, OPFMoveToCustomError, copySlides, edit, embed, fill, fillRecords, localAssetSources, moveToCustom, parseSlideSelection, sameRecord, stats, updateFromCatalog } from './chunk-D25BNPTW.js';
+import { OPFApiError } from './chunk-TMREBZBQ.js';
+export { OPFApiError, OPFExportError, OPFImportError, OPFMoveToCustomError, copySlides, edit, embed, fill, fillRecords, localAssetSources, moveToCustom, parseSlideSelection, sameRecord, stats, updateFromCatalog } from './chunk-TMREBZBQ.js';
 export { specFileEntries, specFileKinds, specFilePaths } from './chunk-UJSAR6GF.js';
 export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-PJSPHHRK.js';
-export { OPFDataImportError, ingest, parseTabularData } from './chunk-TKQ2VFV5.js';
-export { OPFPaginationError, paginate, paginateSlide } from './chunk-77KL2PMM.js';
-export { DECK_FORMATS, deckFormatOf, parse, stringify } from './chunk-GIWNHRTX.js';
-export { fromMarkdown, toMarkdown } from './chunk-3S2XVDPN.js';
-import './chunk-VZBFQLCA.js';
+export { OPFDataImportError, ingest, parseTabularData } from './chunk-JSHMFTSY.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-WJ4XTCOD.js';
+export { DECK_FORMATS, deckFormatOf, parse, stringify } from './chunk-OSM3LZ2Y.js';
+export { fromMarkdown, toMarkdown } from './chunk-GNKESMZT.js';
+import './chunk-KZPZRHL6.js';
+export { OPFFormatError, format } from './chunk-O3SA5SJ4.js';
 import './chunk-RYZPBJLB.js';
-export { explain } from './chunk-G5WJMJV3.js';
-import './chunk-H7XMO36O.js';
-import './chunk-PHP45MO7.js';
-export { OPFMarkdownError } from './chunk-Y4TZCE7R.js';
-import './chunk-Y25DYRME.js';
-export { diff, merge } from './chunk-A54NGT2K.js';
-export { CATALOG_SCHEMA, DEFAULT_VALIDATION_THRESHOLDS, OPFPatchError, OPFPatchValidationError, OPFValidationError, applyPatch, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogSchemaNames, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-IVPA6NG6.js';
-export { CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, CHART_TYPES, DEFAULT_VARIABLE_DATE_FORMAT, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, LANGUAGES, LOGO_SHAPES, OPFCatalogsOptionError, OPFUnresolvedReferenceError, OPFVariableError, SLIDE_SCOPED_BUILTINS, SOCIAL_PLATFORMS, VARIABLE_KINDS, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, chartNumber, coerceVariableValue, datasetDiagnostics, formatDataNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, listBuiltinVariables, listVariables, normalizeLanguageFamily, numberFormatError, parseReference, resolveChartData, resolveDesignRecords, resolveFontScheme, resolveReference, resolveSlideVariables, resolveTableData, resolveVariables, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unresolvedReference, unusedDatasets, variableDeclarations } from './chunk-XRMV2GMB.js';
-export { OPFFormatError, format } from './chunk-EQ6S5SEZ.js';
-export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-F4HFDP6I.js';
+export { explain } from './chunk-CXPBU5W4.js';
+import './chunk-353VBJ6K.js';
+import './chunk-EO3JWEO5.js';
+export { OPFMarkdownError } from './chunk-SYW4BCGZ.js';
+import './chunk-ABFDFZIW.js';
+export { OPFIdError, assignIds, touches } from './chunk-4ACS57MG.js';
+export { diff, merge } from './chunk-APLNGCEZ.js';
+export { CATALOG_SCHEMA, DEFAULT_VALIDATION_THRESHOLDS, OPFPatchError, OPFPatchHashError, OPFPatchValidationError, OPFValidationError, applyPatch, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogSchemaNames, documentHash, findValidationRule, idToken, isIdToken, resolveIdPatch, resolveIdPointer, resolveSlideContext, toIdPatch, toIdPointer, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-PAGVSTVF.js';
+import './chunk-JBARNYFR.js';
+export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-4ZM5G3XX.js';
+export { CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, CHART_TYPES, DEFAULT_VARIABLE_DATE_FORMAT, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, LANGUAGES, LOGO_SHAPES, OPFCatalogsOptionError, OPFUnresolvedReferenceError, OPFVariableError, SLIDE_SCOPED_BUILTINS, SOCIAL_PLATFORMS, VARIABLE_KINDS, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, chartNumber, coerceVariableValue, datasetDiagnostics, formatDataNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, listBuiltinVariables, listVariables, normalizeLanguageFamily, numberFormatError, parseReference, resolveChartData, resolveDesignRecords, resolveFontScheme, resolveReference, resolveSlideVariables, resolveTableData, resolveVariables, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unresolvedReference, unusedDatasets, variableDeclarations } from './chunk-LRTQXGJO.js';
+import './chunk-GM7WFPGG.js';
 
 // src/browser.ts
 var nodeOnly = (name, message) => new OPFApiError(`\`${name}\` ${message}`, "node-only", { details: { function: name, build: "browser" } });

package/dist/{chunk-H7XMO36O.js → chunk-353VBJ6K.js}

@@ -1,8 +1,8 @@
-import { parseQuoteLines, levelsFromIndents, parseCodeFence, splitWhen } from './chunk-PHP45MO7.js';
-import { Ctx, splitLines, lineRange, readYamlMapping, readCsv, DECIMAL } from './chunk-Y4TZCE7R.js';
-import { runText, isRecord, FORMATTING } from './chunk-Y25DYRME.js';
-import { METRIC_KEYS, nearest, BLOCK_AS_VALUES, SLIDE_OPTION_KEYS, BLOCK_OPTION_KEYS } from './chunk-IVPA6NG6.js';
-import { PROMOTED_REGION_KEY } from './chunk-XRMV2GMB.js';
+import { parseQuoteLines, levelsFromIndents, parseCodeFence, splitWhen } from './chunk-EO3JWEO5.js';
+import { Ctx, splitLines, lineRange, readYamlMapping, readCsv, DECIMAL } from './chunk-SYW4BCGZ.js';
+import { runText, isRecord, FORMATTING } from './chunk-ABFDFZIW.js';
+import { METRIC_KEYS, nearest, BLOCK_AS_VALUES, SLIDE_OPTION_KEYS, BLOCK_OPTION_KEYS } from './chunk-PAGVSTVF.js';
+import { PROMOTED_REGION_KEY } from './chunk-LRTQXGJO.js';
 
 // src/markdown/inline.ts
 var PUNCT = /[\p{P}\p{S}]/u;

package/dist/chunk-43JWUIGF.js

@@ -0,0 +1,8 @@
+// src/schema-engine.ts
+var installed;
+var installedSchemaEngine = () => installed;
+function installSchemaEngine(engine) {
+  installed = engine;
+}
+
+export { installSchemaEngine, installedSchemaEngine };

package/dist/chunk-4ACS57MG.js

@@ -0,0 +1,236 @@
+import { applyPatch, normalizePatch, walkPatch, toIdPointer, resolveIdPointer, parsePointer, readPointer, idToken, formatPointer, isIdToken } from './chunk-PAGVSTVF.js';
+import { isRecord, visitContentPayloads, promotedRegionKeys } from './chunk-LRTQXGJO.js';
+
+// src/ids.ts
+var INDEX_TOKEN = /^(0|[1-9][0-9]*)$/;
+var OPFIdError = class extends Error {
+  code;
+  /** The JSON Pointer of the slide or payload the error is about, when known. */
+  path;
+  constructor(code, message, path) {
+    super(message);
+    this.name = "OPFIdError";
+    this.code = code;
+    if (path !== void 0) this.path = path;
+  }
+};
+function assignIds(document, options = {}) {
+  if (!isRecord(document)) throw new OPFIdError("invalid-document", "assignIds expects a presentation object.");
+  const taken = /* @__PURE__ */ new Set();
+  const slides = Array.isArray(document.slides) ? document.slides : [];
+  const known = (node) => {
+    if (typeof node.id === "string") taken.add(node.id);
+  };
+  slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    known(slide);
+    visitContentPayloads(slide, `/slides/${index}`, known);
+  });
+  const counters = { slide: 0, block: 0 };
+  const byDefault = (kind) => {
+    let id;
+    do {
+      counters[kind] += 1;
+      id = `${kind}-${counters[kind]}`;
+    } while (taken.has(id));
+    return id;
+  };
+  const idOf = /* @__PURE__ */ new Map();
+  const parentIdOf = (pointer) => {
+    for (let tokens = parsePointer(pointer).slice(0, -1); tokens.length; tokens = tokens.slice(0, -1)) {
+      const id = idOf.get(formatPointer(tokens));
+      if (id !== void 0) return id;
+    }
+    return void 0;
+  };
+  const patch = [];
+  const assigned = [];
+  const visit = (kind, node, pointer) => {
+    if (typeof node.id === "string") {
+      idOf.set(pointer, node.id);
+      return;
+    }
+    if (Object.hasOwn(node, "id")) return;
+    let id;
+    if (options.generate) {
+      const parentId = parentIdOf(pointer);
+      id = options.generate({ kind, pointer, node, ...parentId !== void 0 ? { parentId } : {} });
+      if (typeof id !== "string" || id === "") throw new OPFIdError("invalid-id", `generate returned ${JSON.stringify(id)} for ${pointer}; an id is a non-empty string.`, pointer);
+      if (taken.has(id)) throw new OPFIdError("duplicate-id", `generate returned '${id}' for ${pointer}, which another slide or block already has.`, pointer);
+    } else id = byDefault(kind);
+    taken.add(id);
+    idOf.set(pointer, id);
+    patch.push({ op: "add", path: `${pointer}/id`, value: id });
+    assigned.push({ pointer, kind, id });
+  };
+  slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const pointer = `/slides/${index}`;
+    visit("slide", slide, pointer);
+    visitContentPayloads(slide, pointer, (payload, path) => visit("block", payload, path));
+  });
+  return { document: applyPatch(document, patch), patch, assigned };
+}
+var KIND_ORDER = ["document", "slide-order", "slide", "block", "design", "assets", "catalogs", "metadata"];
+var AREAS = { design: "design", assets: "assets", catalogs: "catalogs" };
+function elementAt(array, token) {
+  if (isIdToken(token)) {
+    const id = token.slice(1);
+    const node = Array.isArray(array) ? array.find((item) => isRecord(item) && item.id === id) : void 0;
+    return { id, ...isRecord(node) ? { node } : {} };
+  }
+  if (Array.isArray(array) && INDEX_TOKEN.test(token)) {
+    const node = array[Number(token)];
+    if (isRecord(node)) return { ...typeof node.id === "string" && node.id !== "" ? { id: node.id } : {}, node };
+  }
+  return {};
+}
+function locate(tokens, document, readOnlyOrReplace) {
+  const ids = [], slideIds = [];
+  const out = (kind2, shape2) => ({ kind: kind2, shape: shape2, ids, slideIds });
+  if (!tokens.length) return out("document", "document");
+  if (tokens[0] !== "slides") return out(AREAS[tokens[0]] ?? "metadata", "other");
+  if (tokens.length === 1) return out("slide-order", "slides");
+  const slide = elementAt(isRecord(document) ? document.slides : void 0, tokens[1]);
+  if (slide.id !== void 0) {
+    ids.push(slide.id);
+    slideIds.push(slide.id);
+  }
+  if (tokens.length === 2) return out(readOnlyOrReplace ? "slide" : "slide-order", "slide");
+  if (tokens[2] === "design") return out("design", "other");
+  let kind = "slide", shape = "other";
+  let node = slide.node, slideLevel = true;
+  for (let i = 2; i < tokens.length; ) {
+    const token = tokens[i];
+    if (slideLevel && promotedRegionKeys.includes(token)) {
+      const child = node?.[token];
+      if (isRecord(child) && typeof child.id === "string") ids.push(child.id);
+      kind = "block";
+      node = isRecord(child) ? child : void 0;
+      slideLevel = false;
+      i += 1;
+      shape = i === tokens.length ? "payload" : "other";
+    } else if (token === "blocks") {
+      kind = "block";
+      i += 1;
+      if (i === tokens.length) {
+        shape = "payloads";
+        break;
+      }
+      const child = elementAt(node?.blocks, tokens[i]);
+      if (child.id !== void 0) ids.push(child.id);
+      node = child.node;
+      slideLevel = false;
+      i += 1;
+      shape = i === tokens.length ? "payload" : "other";
+    } else break;
+  }
+  return out(kind, shape);
+}
+function idsWithin(shape, value, into) {
+  const payload = (node, slide) => {
+    if (!isRecord(node)) return;
+    if (typeof node.id === "string") {
+      into.ids.push(node.id);
+      if (slide) into.slideIds.push(node.id);
+    }
+    visitContentPayloads(node, "", (child) => {
+      if (typeof child.id === "string") into.ids.push(child.id);
+    });
+  };
+  if (shape === "document") {
+    if (isRecord(value) && Array.isArray(value.slides)) for (const slide of value.slides) payload(slide, true);
+  } else if (shape === "slides") {
+    if (Array.isArray(value)) for (const slide of value) payload(slide, true);
+  } else if (shape === "slide") payload(value, true);
+  else if (shape === "payloads") {
+    if (Array.isArray(value)) for (const child of value) payload(child, false);
+  } else if (shape === "payload") payload(value, false);
+}
+var unique = (list) => [...new Set(list)];
+function insertionIdPointer(state, path, value) {
+  const named = parsePointer(toIdPointer(state, path, { keepLast: true }));
+  const resolved = parsePointer(resolveIdPointer(state, path));
+  if (named.length && isRecord(value) && typeof value.id === "string" && value.id !== "") {
+    const parent = readPointer(state, resolved.slice(0, -1));
+    if (parent.found && Array.isArray(parent.value)) named[named.length - 1] = idToken(value.id);
+  }
+  return formatPointer(named);
+}
+function touches(patch, document) {
+  const reads = [];
+  const writes = [];
+  const record = (list, index, operation, pointer, state, values, idPointer) => {
+    const tokens = parsePointer(pointer);
+    const where = locate(tokens, state, operation.op === "replace" || operation.op === "test" || list === reads);
+    const found = { ids: where.ids, slideIds: where.slideIds };
+    for (const value of values) idsWithin(where.shape, value, found);
+    list.push({ operation: index, op: operation.op, pointer, idPointer: idPointer ?? pointer, kind: where.kind, ids: unique(found.ids), slideIds: unique(found.slideIds) });
+  };
+  if (document === void 0) {
+    normalizePatch(patch).forEach((operation, index) => {
+      switch (operation.op) {
+        case "add":
+        case "replace":
+          record(writes, index, operation, operation.path, void 0, [operation.value]);
+          break;
+        case "remove":
+          record(writes, index, operation, operation.path, void 0, []);
+          break;
+        case "test":
+          record(reads, index, operation, operation.path, void 0, [operation.value]);
+          break;
+        case "copy":
+          record(reads, index, operation, operation.from, void 0, []);
+          record(writes, index, operation, operation.path, void 0, []);
+          break;
+        case "move":
+          record(writes, index, operation, operation.from, void 0, []);
+          record(writes, index, operation, operation.path, void 0, []);
+          break;
+      }
+    });
+  } else {
+    const carried = /* @__PURE__ */ new Map();
+    const insertion = /* @__PURE__ */ new Map();
+    const valueAt = (state, pointer) => {
+      const found = readPointer(state, pointer);
+      return found.found ? [found.value] : [];
+    };
+    walkPatch(document, patch, {
+      before: (index, operation, working) => {
+        if (operation.op === "add") {
+          insertion.set(index, insertionIdPointer(working, operation.path, operation.value));
+          return;
+        }
+        const source = operation.op === "copy" || operation.op === "move" ? operation.from : operation.path;
+        const pointer = resolveIdPointer(working, source);
+        const old = valueAt(working, pointer);
+        if (operation.op === "copy" || operation.op === "move") carried.set(index, old[0]);
+        if (operation.op === "copy") insertion.set(index, insertionIdPointer(working, operation.path, old[0]));
+        const idPointer = toIdPointer(working, pointer);
+        if (operation.op === "test") record(reads, index, operation, pointer, working, old, idPointer);
+        else if (operation.op === "copy") record(reads, index, operation, pointer, working, old, idPointer);
+        else if (operation.op === "replace") record(writes, index, operation, pointer, working, [...old, operation.value], idPointer);
+        else record(writes, index, operation, pointer, working, old, idPointer);
+      },
+      after: (step, working) => {
+        const { operation, resolved, index } = step;
+        if (operation.op !== "add" && operation.op !== "copy" && operation.op !== "move") return;
+        const value = operation.op === "add" ? operation.value : carried.get(index);
+        const idPointer = operation.op === "move" ? toIdPointer(working, resolved.path) : insertion.get(index);
+        record(writes, index, operation, resolved.path, working, [value], idPointer);
+      }
+    });
+  }
+  const all = [...reads, ...writes];
+  return {
+    reads,
+    writes,
+    ids: unique(all.flatMap((touch) => touch.ids)),
+    slideIds: unique(all.flatMap((touch) => touch.slideIds)),
+    kinds: KIND_ORDER.filter((kind) => all.some((touch) => touch.kind === kind))
+  };
+}
+
+export { OPFIdError, assignIds, touches };

package/dist/{chunk-F4HFDP6I.js → chunk-4ZM5G3XX.js}

@@ -5550,7 +5550,7 @@ var presentation = {
               "$ref": "#/$defs/TableCellBorder"
             }
           },
-          "description": "Independent cell edges. Omitted edges retain the table theme border; width 0 removes an edge."
+          "description": "Independent cell edges. An omitted edge keeps the table's default rule: a line under every row (and over the first row), none between columns. Width 0 removes an edge."
         }
       },
       "description": "Cell appearance. Sizes use reference pixels at a 720-pixel canvas short edge and scale with the slide."

package/dist/{chunk-NVT2YDVC.js → chunk-7XUEKIXH.js}

@@ -1,5 +1,5 @@
-import { OPFApiError } from './chunk-D25BNPTW.js';
-import { CATALOG_SCHEMA } from './chunk-IVPA6NG6.js';
+import { OPFApiError } from './chunk-TMREBZBQ.js';
+import { CATALOG_SCHEMA } from './chunk-PAGVSTVF.js';
 import { CATALOG_SCHEMA as CATALOG_SCHEMA$1, gallery } from '@openpresentation/gallery';
 
 function galleryMismatch(declared, reads = CATALOG_SCHEMA) {

package/dist/{chunk-Y25DYRME.js → chunk-ABFDFZIW.js}

@@ -1,4 +1,4 @@
-import { validate } from './chunk-IVPA6NG6.js';
+import { validate } from './chunk-PAGVSTVF.js';
 
 // src/convert/shared.ts
 var CONTENT_KEYS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];

package/dist/{chunk-A54NGT2K.js → chunk-APLNGCEZ.js}

@@ -1,5 +1,5 @@
-import { jsonEqual, formatPointer } from './chunk-IVPA6NG6.js';
-import { annotationText } from './chunk-XRMV2GMB.js';
+import { jsonEqual, formatPointer } from './chunk-PAGVSTVF.js';
+import { annotationText } from './chunk-LRTQXGJO.js';
 
 // src/diff-match.ts
 var DEFAULT_MATCH_THRESHOLD = 0.5;

package/dist/{chunk-G5WJMJV3.js → chunk-CXPBU5W4.js}

@@ -1,4 +1,4 @@
-import { SOURCE_EXPLAIN, ruleDocumentation, findValidationRule, us } from './chunk-IVPA6NG6.js';
+import { SOURCE_EXPLAIN, ruleDocumentation, findValidationRule, us } from './chunk-PAGVSTVF.js';
 
 // src/finding-text-explain-util.ts
 var ex = (fix, problem, fixed) => ({ fix, problem, fixed });

package/dist/{chunk-PHP45MO7.js → chunk-EO3JWEO5.js}

@@ -1,4 +1,4 @@
-import { runText } from './chunk-Y25DYRME.js';
+import { runText } from './chunk-ABFDFZIW.js';
 
 // src/convert/text-lines.ts
 var LIST_PREFIX = /^([ \t]*)(?:([-*•+]|\d{1,3}[.)])[ \t]+)?/;