@openpresentation/opf 0.13.0 → 0.15.1

package/dist/chunk-3RKB4RDJ.js

@@ -0,0 +1,192 @@
+import { isRecord, same } from './chunk-VGAOJEY7.js';
+import { parseDocument, YAMLMap, Scalar, stringify } from 'yaml';
+
+function splitLines(source) {
+  const lines = [];
+  let start = 0;
+  let no = 1;
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\n" || c === "\r") {
+      lines.push({ text: source.slice(start, i), start, end: i, no: no++ });
+      if (c === "\r" && source[i + 1] === "\n") i++;
+      i++;
+      start = i;
+    } else i++;
+  }
+  if (start < source.length) lines.push({ text: source.slice(start), start, end: source.length, no });
+  return lines;
+}
+var Ctx = class {
+  constructor(source) {
+    this.source = source;
+    for (let i = 0; i < source.length; i++) {
+      if (source[i] === "\r") {
+        if (source[i + 1] === "\n") i++;
+        this.lineStarts.push(i + 1);
+      } else if (source[i] === "\n") this.lineStarts.push(i + 1);
+    }
+  }
+  source;
+  findings = [];
+  /** JSON Pointer in the converted document to the source range that produced it. */
+  ranges = /* @__PURE__ */ new Map();
+  lineStarts = [0];
+  location(range) {
+    let lo = 0;
+    let hi = this.lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((this.lineStarts[mid] ?? 0) <= range.start) lo = mid;
+      else hi = mid;
+    }
+    return { offset: range.start, length: Math.max(0, range.end - range.start), line: lo + 1, column: range.start - (this.lineStarts[lo] ?? 0) + 1 };
+  }
+  report(ruleId, severity, message, help, range, path = "") {
+    this.findings.push({ ruleId, severity, category: "format", scope: "document", path, message, help, location: this.location(range) });
+  }
+  error(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "error", message, help, range, path);
+  }
+  warn(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "warning", message, help, range, path);
+  }
+  get errors() {
+    return this.findings.filter((d) => d.severity === "error").length;
+  }
+  /** The source range of a JSON Pointer, falling back to the nearest ancestor that has one. */
+  rangeOf(pointer) {
+    for (let path = pointer; ; path = path.slice(0, path.lastIndexOf("/"))) {
+      const found = this.ranges.get(path);
+      if (found) return found;
+      if (!path) return void 0;
+    }
+  }
+};
+var lineRange = (first, last = first) => ({ start: first.start, end: last.end });
+function readYamlMapping(text, base, ctx, rule, context) {
+  const keys = /* @__PURE__ */ new Map();
+  const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false, prettyErrors: false });
+  let ok = true;
+  for (const error of doc.errors) {
+    ok = false;
+    const [start, end] = error.pos;
+    ctx.error(rule, `YAML: ${error.message.split("\n")[0]}`, "Fix the YAML syntax. Front matter and embedded blocks hold JSON-compatible YAML: mappings, sequences and scalars, no anchors or tags.", { start: base + start, end: base + Math.max(end, start) });
+  }
+  if (!ok) return { value: {}, keys, ok };
+  if (doc.contents === null) return { value: {}, keys, ok };
+  if (!(doc.contents instanceof YAMLMap)) {
+    ctx.error(`${rule}-not-mapping`, "Expected a YAML mapping of keys and values.", "Write `key: value` lines; a list or a bare value is not accepted here.", context);
+    return { value: {}, keys, ok: false };
+  }
+  for (const pair of doc.contents.items) {
+    const key = pair.key;
+    const name = key instanceof Scalar ? String(key.value) : void 0;
+    if (name !== void 0 && key?.range) keys.set(name, { start: base + key.range[0], end: base + (pair.value?.range?.[1] ?? key.range[1]) });
+  }
+  let value;
+  try {
+    value = doc.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    ctx.error(rule, `YAML: ${error.message}`, "Anchors and aliases are not accepted; write each value out.", context);
+    return { value: {}, keys, ok: false };
+  }
+  const bad = nonJson(value);
+  if (bad) {
+    ctx.error(rule, `YAML value is not JSON-compatible (${bad}).`, "Quote special numbers such as .inf or .nan to keep them as strings.", context);
+    return { value: {}, keys, ok: false };
+  }
+  return { value, keys, ok };
+}
+function nonJson(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? void 0 : "a number that is not finite";
+  if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
+  if (Array.isArray(value)) return value.map(nonJson).find(Boolean);
+  if (isRecord(value)) return Object.values(value).map(nonJson).find(Boolean);
+  return `a ${typeof value}`;
+}
+function writeYaml(value) {
+  for (const blockQuote of [true, false]) {
+    const text = stringify(value, { indent: 2, lineWidth: 0, minContentWidth: 0, blockQuote, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
+    const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false });
+    if (!doc.errors.length && same(doc.toJS({ maxAliasCount: 0 }), value)) return text.endsWith("\n") ? text : `${text}
+`;
+  }
+  return void 0;
+}
+var DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function scalarText(value) {
+  if (typeof value === "number") return DECIMAL.test(String(value)) ? String(value) : JSON.stringify(String(value));
+  const plain = value !== "" && value === value.trim() && !value.startsWith('"') && !/[\r\n]/.test(value) && !DECIMAL.test(value);
+  return plain ? value : JSON.stringify(value);
+}
+function readCsv(text) {
+  const rows = [];
+  let row = [];
+  let i = 0;
+  const n = text.length;
+  const endRecord = () => {
+    rows.push(row);
+    row = [];
+  };
+  while (i < n) {
+    while (text[i] === " " || text[i] === "	") i++;
+    if (text[i] === '"') {
+      let value = "";
+      i++;
+      for (; ; ) {
+        if (i >= n) return { rows, error: "A quoted field is not closed." };
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += text[i++];
+      }
+      while (text[i] === " " || text[i] === "	") i++;
+      if (i < n && text[i] !== "," && text[i] !== "\n" && text[i] !== "\r") return { rows, error: "Text follows a closing quote." };
+      row.push({ value, quoted: true });
+    } else {
+      let j = i;
+      while (j < n && text[j] !== "," && text[j] !== "\n" && text[j] !== "\r") j++;
+      row.push({ value: text.slice(i, j).trim(), quoted: false });
+      i = j;
+    }
+    if (text[i] === ",") {
+      i++;
+      if (i >= n || text[i] === "\n" || text[i] === "\r") row.push({ value: "", quoted: false });
+      continue;
+    }
+    if (text[i] === "\r" && text[i + 1] === "\n") i++;
+    i++;
+    endRecord();
+  }
+  if (row.length) endRecord();
+  return { rows };
+}
+var needsQuotes = (value) => /[",\r\n]/.test(value) || value !== value.trim() || value === "";
+function csvField(cell, header = false) {
+  if (cell === null) return "";
+  if (typeof cell === "number") return String(cell);
+  if (typeof cell === "boolean") return String(cell);
+  const text = String(cell);
+  const ambiguous = !header && (DECIMAL.test(text) || /^(?:true|false)$/.test(text));
+  return needsQuotes(text) || ambiguous ? `"${text.replaceAll('"', '""')}"` : text;
+}
+var OPFMarkdownError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OPFMarkdownError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+export { Ctx, DECIMAL, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };

package/dist/{chunk-IS2CPNVJ.js → chunk-5FTUIDUH.js}

@@ -1,7 +1,7 @@
-import { validatePresentation } from './chunk-IYCJUKWD.js';
+import { validate } from './chunk-QDI75P2M.js';
 
 // src/patch.ts
-var PatchError = class extends Error {
+var OPFPatchError = class extends Error {
   code;
   /** The JSON Pointer the failing operation addressed, when known. */
   path;
@@ -11,18 +11,18 @@ var PatchError = class extends Error {
   operation;
   constructor(code, message, details = {}) {
     super(message);
-    this.name = "PatchError";
+    this.name = "OPFPatchError";
     this.code = code;
     if (details.path !== void 0) this.path = details.path;
     if (details.index !== void 0) this.index = details.index;
     if (details.operation !== void 0) this.operation = details.operation;
   }
 };
-var PatchValidationError = class extends PatchError {
+var OPFPatchValidationError = class extends OPFPatchError {
   validation;
   constructor(validation) {
     super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
-    this.name = "PatchValidationError";
+    this.name = "OPFPatchValidationError";
     this.validation = validation;
   }
 };
@@ -49,7 +49,7 @@ function unescapePointerToken(token) {
 }
 function parsePointer(pointer) {
   if (typeof pointer !== "string" || pointer !== "" && !pointer.startsWith("/") || /~(?![01])/u.test(pointer)) {
-    throw new PatchError("invalid-json-pointer", "Expected a JSON Pointer (empty string or /path with ~0 and ~1 escapes).", { path: typeof pointer === "string" ? pointer : void 0 });
+    throw new OPFPatchError("invalid-json-pointer", "Expected a JSON Pointer (empty string or /path with ~0 and ~1 escapes).", { path: typeof pointer === "string" ? pointer : void 0 });
   }
   return pointer === "" ? [] : pointer.slice(1).split("/").map(unescapePointerToken);
 }
@@ -58,7 +58,7 @@ function formatPointer(tokens) {
 }
 function pointerFromPath(path) {
   if (Array.isArray(path)) return formatPointer(path);
-  if (typeof path !== "string") throw new PatchError("invalid-json-pointer", "A path must be a string or an array of segments.");
+  if (typeof path !== "string") throw new OPFPatchError("invalid-json-pointer", "A path must be a string or an array of segments.");
   if (path === "") return "";
   if (path.startsWith("/")) {
     parsePointer(path);
@@ -68,7 +68,7 @@ function pointerFromPath(path) {
 }
 function splitPointer(pointer) {
   const tokens = parsePointer(pointer);
-  if (!tokens.length) throw new PatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer });
+  if (!tokens.length) throw new OPFPatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer });
   return { parent: formatPointer(tokens.slice(0, -1)), token: tokens[tokens.length - 1] };
 }
 function readPointer(document, pointer) {
@@ -89,24 +89,24 @@ function getAtPointer(document, pointer) {
   const result = readPointer(document, pointer);
   if (!result.found) {
     const shown = typeof pointer === "string" ? pointer : formatPointer(pointer);
-    throw new PatchError("patch-path-missing", `Patch path does not exist: ${shown || "/"}`, { path: shown });
+    throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${shown || "/"}`, { path: shown });
   }
   return result.value;
 }
 var hasPointer = (document, pointer) => readPointer(document, pointer).found;
 function arrayIndex(token, length, allowEnd, path) {
   if (allowEnd && token === "-") return length;
-  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new PatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
+  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
   const at = Number(token);
-  if (!Number.isSafeInteger(at) || at > length || !allowEnd && at >= length) throw new PatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
+  if (!Number.isSafeInteger(at) || at > length || !allowEnd && at >= length) throw new OPFPatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
   return at;
 }
 function normalizePatch(patch) {
-  if (!Array.isArray(patch)) throw new PatchError("invalid-patch", "A JSON Patch must be an array of operations.");
+  if (!Array.isArray(patch)) throw new OPFPatchError("invalid-patch", "A JSON Patch must be an array of operations.");
   return patch.map((operation, index) => normalizeOperation(operation, index));
 }
 function normalizeOperation(operation, index) {
-  const fail = (code, message, path) => new PatchError(code, index === void 0 ? message : `Operation ${index}: ${message}`, { index, operation, path });
+  const fail = (code, message, path) => new OPFPatchError(code, index === void 0 ? message : `Operation ${index}: ${message}`, { index, operation, path });
   if (!isObject(operation)) throw fail("invalid-patch-operation", "Expected an operation object.");
   const op = operation.op;
   if (typeof op !== "string" || !["add", "remove", "replace", "move", "copy", "test"].includes(op)) {
@@ -135,7 +135,7 @@ function parentOf(document, tokens, path) {
   const key = tokens[tokens.length - 1];
   const found = readPointer(document, tokens.slice(0, -1));
   if (!found.found || !found.value || typeof found.value !== "object") {
-    throw new PatchError("patch-parent-missing", `Patch parent does not exist for ${path}.`, { path });
+    throw new OPFPatchError("patch-parent-missing", `Patch parent does not exist for ${path}.`, { path });
   }
   return { parent: found.value, key };
 }
@@ -165,7 +165,7 @@ function replaceAt(document, path, value) {
     parent[at] = clone(value);
   } else {
     const record = parent;
-    if (!own(record, key)) throw new PatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+    if (!own(record, key)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
     previous = record[key];
     Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
   }
@@ -173,7 +173,7 @@ function replaceAt(document, path, value) {
 }
 function removeAt(document, path) {
   const tokens = parsePointer(path);
-  if (!tokens.length) throw new PatchError("patch-root-remove", "The document root cannot be removed.", { path });
+  if (!tokens.length) throw new OPFPatchError("patch-root-remove", "The document root cannot be removed.", { path });
   const { parent, key } = parentOf(document, tokens, path);
   let previous;
   if (Array.isArray(parent)) {
@@ -183,7 +183,7 @@ function removeAt(document, path) {
     return { document, inverse: { op: "add", path: formatPointer([...tokens.slice(0, -1), at]), value: clone(previous) } };
   }
   const record = parent;
-  if (!own(record, key)) throw new PatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+  if (!own(record, key)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
   previous = record[key];
   delete record[key];
   return { document, inverse: { op: "add", path, value: clone(previous) } };
@@ -204,7 +204,7 @@ function applyOne(document, operation) {
     }
     case "test": {
       const found = readPointer(document, operation.path);
-      if (!found.found || !jsonEqual(found.value, operation.value)) throw new PatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
+      if (!found.found || !jsonEqual(found.value, operation.value)) throw new OPFPatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
       return { document, inverse: [] };
     }
     case "copy": {
@@ -217,7 +217,7 @@ function applyOne(document, operation) {
       const value = clone(getAtPointer(document, from));
       if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [] };
       if (to.length > from.length && from.every((token, i) => to[i] === token)) {
-        throw new PatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
+        throw new OPFPatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
       }
       const removed = removeAt(document, operation.from);
       const added = addAt(removed.document, operation.path, value);
@@ -235,27 +235,27 @@ function applyPatchWithInverse(document, patch, options = {}) {
       working = step.document;
       inverse.unshift(...step.inverse);
     } catch (error) {
-      if (error instanceof PatchError && error.index === void 0) {
-        const wrapped = new PatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
+      if (error instanceof OPFPatchError && error.index === void 0) {
+        const wrapped = new OPFPatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
         throw wrapped;
       }
       throw error;
     }
   }
-  const result = { document: working, inverse, patch: operations };
+  const result = { presentation: working, inverse, patch: operations };
   if (options.validate) {
-    const validator = typeof options.validate === "function" ? options.validate : (value) => validatePresentation(value);
+    const validator = typeof options.validate === "function" ? options.validate : (value) => validate(value, { only: options.strict ? ["format", "references"] : ["format"] });
     const validation = validator(working);
-    if (!validation.valid || options.strict && Array.isArray(validation.warnings) && validation.warnings.length) throw new PatchValidationError(validation);
+    if (!validation.valid || options.strict && validation.findings?.some((entry) => entry.severity === "warning")) throw new OPFPatchValidationError(validation);
     result.validation = validation;
   }
   return result;
 }
 function applyPatch(document, patch, options = {}) {
-  return applyPatchWithInverse(document, patch, options).document;
+  return applyPatchWithInverse(document, patch, options).presentation;
 }
 function invertPatch(document, patch) {
   return applyPatchWithInverse(document, patch).inverse;
 }
 
-export { PatchError, PatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };