@openpresentation/opf 0.11.4 → 0.12.1

package/dist/{chunk-3OJN7QAW.js → chunk-MWPMJE6P.js}

@@ -1,6 +1,6 @@
-import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-FDCWQHWO.js';
-import { schemas, schemaEntries } from './chunk-KJKASEPE.js';
-import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-AEUSVEUY.js';
+import { validatePresentation, unusedReferenceWarnings, validationDefinition, validateCatalogRecord } from './chunk-JKVKYVWL.js';
+import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-E34DJ5LL.js';
+import { schemas, schemaEntries } from './chunk-4LAM3N6S.js';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
 
 var own = (value, key) => Object.hasOwn(value, key);
@@ -367,7 +367,9 @@ function distance(a, b) {
 }
 function lintPresentation(document, options = {}) {
   optionsChecked(options);
-  const validation = validatePresentation(document), diagnostics = validation.errors.map((issue) => schemaDiagnostic(issue));
+  const validation = validatePresentation(document), diagnostics = validation.errors.map(
+    (issue) => typeof issue.params.code === "string" && issue.keyword === "opf" ? { ...schemaDiagnostic(issue), ruleId: `opf/${issue.params.code}` } : schemaDiagnostic(issue)
+  );
   const catalogs = catalogContext(document, options, diagnostics), seen = /* @__PURE__ */ new Set();
   const assetValues = object(document) && object(document.assets) ? document.assets : {};
   for (const field of fields(document)) {
@@ -515,6 +517,18 @@ function lintPresentation(document, options = {}) {
       }
     }
   }
+  for (const issue of unusedReferenceWarnings(document))
+    diagnostics.push({
+      ruleId: "opf/unused-reference",
+      severity: "warning",
+      scope: "document",
+      path: issue.path,
+      message: issue.message,
+      help: "Cite the reference from a text, bullet or list item run ({ text, cite: id }) so it is listed in that slide's footnote area, or remove the entry. Nothing is drawn for an uncited reference.",
+      definition: schemas.presentation.$id + "#/$defs/Reference",
+      lookup: ["opf", "schema", "presentation", "/$defs/Reference"],
+      validation: issue
+    });
   return report(diagnostics, validation.valid, "not-applicable");
 }
 function lintSource(source, options = {}) {

package/dist/chunk-RUC7L5DJ.js

@@ -0,0 +1,261 @@
+import { validatePresentation } from './chunk-JKVKYVWL.js';
+
+// src/patch.ts
+var PatchError = class extends Error {
+  code;
+  /** The JSON Pointer the failing operation addressed, when known. */
+  path;
+  /** The index of the failing operation within the patch, when known. */
+  index;
+  /** The failing operation, when known. */
+  operation;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "PatchError";
+    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 {
+  validation;
+  constructor(validation) {
+    super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
+    this.name = "PatchValidationError";
+    this.validation = validation;
+  }
+};
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var clone = (value) => structuredClone(value);
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b;
+    return a.length === other.length && a.every((item, i) => jsonEqual(item, other[i]));
+  }
+  const left = a, right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => own(right, key) && jsonEqual(left[key], right[key]));
+}
+function escapePointerToken(token) {
+  return String(token).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function unescapePointerToken(token) {
+  return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+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 });
+  }
+  return pointer === "" ? [] : pointer.slice(1).split("/").map(unescapePointerToken);
+}
+function formatPointer(tokens) {
+  return tokens.length ? `/${tokens.map(escapePointerToken).join("/")}` : "";
+}
+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 (path === "") return "";
+  if (path.startsWith("/")) {
+    parsePointer(path);
+    return path;
+  }
+  return formatPointer(path.split(".").filter(Boolean));
+}
+function splitPointer(pointer) {
+  const tokens = parsePointer(pointer);
+  if (!tokens.length) throw new PatchError("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) {
+  const tokens = typeof pointer === "string" ? parsePointer(pointer) : pointer;
+  let value = document;
+  for (const token of tokens) {
+    if (Array.isArray(value)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { found: false };
+      const at = Number(token);
+      if (!Number.isSafeInteger(at) || at >= value.length) return { found: false };
+      value = value[at];
+    } else if (value && typeof value === "object" && own(value, token)) value = value[token];
+    else return { found: false };
+  }
+  return { found: true, value };
+}
+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 });
+  }
+  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 });
+  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 });
+  return at;
+}
+function normalizePatch(patch) {
+  if (!Array.isArray(patch)) throw new PatchError("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 });
+  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)) {
+    throw fail("unsupported-patch-operation", `Unknown operation: ${String(op)}`);
+  }
+  if (typeof operation.path !== "string") throw fail("invalid-patch-operation", "An operation needs a string path.");
+  try {
+    parsePointer(operation.path);
+  } catch (error) {
+    throw fail("invalid-json-pointer", error.message, operation.path);
+  }
+  if (op === "move" || op === "copy") {
+    if (typeof operation.from !== "string") throw fail("invalid-patch-operation", `${op} requires a string from.`, operation.path);
+    try {
+      parsePointer(operation.from);
+    } catch (error) {
+      throw fail("invalid-json-pointer", error.message, operation.from);
+    }
+    return { op, from: operation.from, path: operation.path };
+  }
+  if (op === "remove") return { op, path: operation.path };
+  if (!own(operation, "value")) throw fail("invalid-patch-operation", `${op} requires value.`, operation.path);
+  return { op, path: operation.path, value: clone(operation.value) };
+}
+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 });
+  }
+  return { parent: found.value, key };
+}
+var NONE = /* @__PURE__ */ Symbol("none");
+function addAt(document, path, value) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const { parent, key } = parentOf(document, tokens, path);
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, true, path);
+    parent.splice(at, 0, clone(value));
+    return { document, inverse: { op: "remove", path: formatPointer([...tokens.slice(0, -1), at]) } };
+  }
+  const record = parent;
+  const previous = own(record, key) ? record[key] : NONE;
+  Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
+  return { document, inverse: previous === NONE ? { op: "remove", path } : { op: "replace", path, value: clone(previous) } };
+}
+function replaceAt(document, path, value) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const { parent, key } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, false, path);
+    previous = parent[at];
+    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 });
+    previous = record[key];
+    Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
+  }
+  return { document, inverse: { op: "replace", path, value: clone(previous) } };
+}
+function removeAt(document, path) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) throw new PatchError("patch-root-remove", "The document root cannot be removed.", { path });
+  const { parent, key } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, false, path);
+    previous = parent[at];
+    parent.splice(at, 1);
+    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 });
+  previous = record[key];
+  delete record[key];
+  return { document, inverse: { op: "add", path, value: clone(previous) } };
+}
+function applyOne(document, operation) {
+  switch (operation.op) {
+    case "add": {
+      const r = addAt(document, operation.path, operation.value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "replace": {
+      const r = replaceAt(document, operation.path, operation.value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "remove": {
+      const r = removeAt(document, operation.path);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    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 });
+      return { document, inverse: [] };
+    }
+    case "copy": {
+      const value = clone(getAtPointer(document, operation.from));
+      const r = addAt(document, operation.path, value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "move": {
+      const from = parsePointer(operation.from), to = parsePointer(operation.path);
+      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 });
+      }
+      const removed = removeAt(document, operation.from);
+      const added = addAt(removed.document, operation.path, value);
+      return { document: added.document, inverse: [added.inverse, removed.inverse] };
+    }
+  }
+}
+function applyPatchWithInverse(document, patch, options = {}) {
+  const operations = normalizePatch(patch);
+  let working = clone(document);
+  const inverse = [];
+  for (const [index, operation] of operations.entries()) {
+    try {
+      const step = applyOne(working, operation);
+      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 });
+        throw wrapped;
+      }
+      throw error;
+    }
+  }
+  const result = { document: working, inverse, patch: operations };
+  if (options.validate) {
+    const validator = typeof options.validate === "function" ? options.validate : (value) => validatePresentation(value);
+    const validation = validator(working);
+    if (!validation.valid || options.strict && Array.isArray(validation.warnings) && validation.warnings.length) throw new PatchValidationError(validation);
+    result.validation = validation;
+  }
+  return result;
+}
+function applyPatch(document, patch, options = {}) {
+  return applyPatchWithInverse(document, patch, options).document;
+}
+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 };

package/dist/chunk-S5W34SIJ.js

@@ -0,0 +1 @@
+

package/dist/chunk-V2537ENL.js

@@ -0,0 +1,198 @@
+import { validatePresentation } from './chunk-JKVKYVWL.js';
+
+// src/convert/shared.ts
+var CONTENT_KEYS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var SLIDE_ONLY_KEYS = ["title", "subtitle", "tag", "layout", "design", "notes", "section", "hidden", "beat"];
+var OPFConversionError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OPFConversionError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var refuse = (message, details = {}) => new OPFConversionError("not-convertible", message, details);
+var Loss = class {
+  list = [];
+  note(message) {
+    if (!this.list.includes(message)) this.list.push(message);
+  }
+  merge(other) {
+    for (const message of other) this.note(message);
+  }
+};
+var report = (loss) => ({ lossless: loss.length === 0, loss: [...loss] });
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var clone = (value) => structuredClone(value);
+var own = (value, key) => Object.hasOwn(value, key);
+var same = (a, b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+  return value;
+}
+var isSlideLike = (payload) => SLIDE_ONLY_KEYS.some((key) => own(payload, key));
+var contentKeysOf = (payload) => CONTENT_KEYS.filter((key) => payload[key] !== void 0);
+function assertValidOutput(value, as = "block") {
+  const slides = as === "slides" ? value : as === "slide" ? [value] : [{ blocks: [value] }];
+  const result = validatePresentation({ slides });
+  if (!result.valid) {
+    const first = result.errors[0];
+    throw new OPFConversionError("invalid-output", `The converted content is not valid OPF: ${first?.message ?? "unknown error"}${first?.path ? ` (${first.path})` : ""}.`, { issues: result.errors });
+  }
+}
+var assertValidOwner = (owner) => assertValidOutput(owner, isSlideLike(owner) ? "slide" : "block");
+var FORMATTING = ["bold", "italic", "underline", "strikethrough", "color", "fontSize", "fontFamily", "link", "superscript", "subscript"];
+var isPlainRun = (run) => typeof run === "string" || isRecord(run) && !FORMATTING.some((key) => run[key] !== void 0);
+var runText = (run) => typeof run === "string" ? run : run.text ?? "";
+var runsOf = (value) => typeof value === "string" ? [value] : Array.isArray(value) ? value : [];
+var plainOf = (value) => runsOf(value).map(runText).join("");
+var hasFormatting = (value) => runsOf(value).some((run) => !isPlainRun(run));
+var NEWLINE = /\r\n|\r|\n/;
+function splitRuns(runs) {
+  const lines = [[]];
+  for (const run of runs) {
+    const parts = runText(run).split(NEWLINE);
+    parts.forEach((part, index) => {
+      if (index > 0) lines.push([]);
+      if (part === "") return;
+      lines[lines.length - 1].push(typeof run === "string" ? part : { ...run, text: part });
+    });
+  }
+  return lines;
+}
+function mergeRuns(runs) {
+  const merged = [];
+  for (const run of runs) {
+    if (typeof run === "string" && typeof merged.at(-1) === "string") merged[merged.length - 1] += run;
+    else merged.push(run);
+  }
+  return merged;
+}
+var linePlain = (line) => line.map(runText).join("");
+var lineIsPlain = (line) => line.every(isPlainRun);
+var lineValue = (line) => lineIsPlain(line) ? linePlain(line) : mergeRuns(line);
+function joinLines(lines) {
+  if (lines.every(lineIsPlain)) return lines.map(linePlain).join("\n");
+  const runs = [];
+  lines.forEach((line, index) => {
+    if (index > 0) runs.push("\n");
+    runs.push(...line);
+  });
+  return mergeRuns(runs);
+}
+function concatText(a, b) {
+  if (typeof a === "string" && typeof b === "string") return a + b;
+  return mergeRuns([...runsOf(a), ...runsOf(b)]);
+}
+
+// src/convert/text-lines.ts
+var LIST_PREFIX = /^([ \t]*)(?:([-*•+]|\d{1,3}[.)])[ \t]+)?/;
+var indentWidth = (space) => [...space].reduce((width, char) => width + (char === "	" ? 4 : 1), 0);
+function parseListLine(line) {
+  const first = line[0];
+  if (first === void 0) return { line, indent: 0, numbered: false, marked: false };
+  const text = runText(first);
+  const match = LIST_PREFIX.exec(text);
+  const rest = text.slice(match[0].length);
+  const next = [...line];
+  if (rest === "") next.shift();
+  else next[0] = typeof first === "string" ? rest : { ...first, text: rest };
+  return { line: next, indent: indentWidth(match[1] ?? ""), numbered: /^\d/.test(match[2] ?? ""), marked: match[2] !== void 0 };
+}
+function levelsFromIndents(indents) {
+  const stack = [];
+  return indents.map((width) => {
+    while (stack.length && stack.at(-1) > width) stack.pop();
+    if (!stack.length || stack.at(-1) < width) stack.push(width);
+    return stack.length - 1;
+  });
+}
+var STRONG_DASH = /^\s*(?:—|–|―|--|~)\s*(\S.*?)\s*$/;
+var WEAK_DASH = /^\s*-\s+(\S.*?)\s*$/;
+var MAX_ATTRIBUTION = 120;
+var OPEN_QUOTE = /^\s*[“"‘«„]/;
+var INLINE_ATTRIBUTION = /^(.*[”"’»“])\s+[—–]\s+(\S.*?)\s*$/;
+function parseQuoteLines(lines) {
+  const attributionOf = (line, body) => {
+    const strong = STRONG_DASH.exec(line);
+    const weak = strong ? void 0 : WEAK_DASH.exec(line);
+    const text = (strong ?? weak)?.[1];
+    if (!text || text.length > MAX_ATTRIBUTION) return void 0;
+    if (weak && body.length && body.every((entry) => /^\s*-\s+/.test(entry))) return void 0;
+    return text;
+  };
+  if (lines.length >= 2) {
+    const last = attributionOf(lines.at(-1), lines.slice(0, -1));
+    if (last !== void 0) {
+      if (lines.length >= 3) {
+        const middle = attributionOf(lines.at(-2), lines.slice(0, -2));
+        if (middle !== void 0) return { text: lines.slice(0, -2), attribution: middle, source: last };
+      }
+      return { text: lines.slice(0, -1), attribution: last };
+    }
+  }
+  const final = lines.at(-1);
+  if (final !== void 0) {
+    const inline = INLINE_ATTRIBUTION.exec(final);
+    if (inline && OPEN_QUOTE.test(lines[0]) && inline[2].length <= MAX_ATTRIBUTION && !/[—–]/.test(inline[2])) return { text: [...lines.slice(0, -1), inline[1]], attribution: inline[2] };
+  }
+  return { text: lines };
+}
+var MONTH = "(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|June?|July?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\\.?";
+var YEAR = "(?:1[5-9]\\d\\d|2[01]\\d\\d)";
+var WHEN = new RegExp(
+  `^(?:${[
+    `${YEAR}(?:-\\d{2}(?:-\\d{2})?)?`,
+    `${YEAR}[\u2013-]${YEAR}`,
+    `Q[1-4](?:\\s*(?:'\\d{2}|${YEAR}))?`,
+    `${YEAR}\\s*Q[1-4]`,
+    `H[12](?:\\s*${YEAR})?`,
+    `${YEAR}\\s*H[12]`,
+    `${MONTH}(?:\\s+\\d{1,2}(?:st|nd|rd|th)?)?(?:,?\\s+${YEAR})?`,
+    `\\d{1,2}\\s+${MONTH}(?:\\s+${YEAR})?`,
+    "(?:Week|Wk|Day|Month|Sprint|Phase|Step|Stage)\\s+\\d{1,3}"
+  ].join("|")})$`,
+  "i"
+);
+var WHEN_SEPARATOR = /\s*:\s+|\s+[–—-]\s+|\s*[—–]\s*/g;
+var looksLikeWhen = (text) => text.length <= 24 && WHEN.test(text.trim());
+function splitWhen(text, loose = false) {
+  for (const match of text.matchAll(WHEN_SEPARATOR)) {
+    const when = text.slice(0, match.index).trim();
+    const what = text.slice(match.index + match[0].length).trim();
+    if (!when || !what) continue;
+    if (looksLikeWhen(when) || loose && match[0].trim() === ":" && when.length <= 24) return { when, what };
+  }
+  return void 0;
+}
+var FENCE_OPEN = /^\s*(`{3,}|~{3,})[ \t]*([^`\r\n]*?)[ \t]*$/;
+var fenceLine = (char, length) => new RegExp(`^\\s*${char === "`" ? "`" : "~"}{${length},}\\s*$`);
+function parseCodeFence(lines) {
+  if (lines.length < 2) return void 0;
+  const open = FENCE_OPEN.exec(lines[0]);
+  if (!open) return void 0;
+  const fence = open[1];
+  const closing = fenceLine(fence[0], fence.length);
+  if (!closing.test(lines.at(-1))) return void 0;
+  const body = lines.slice(1, -1);
+  if (body.some((line) => closing.test(line))) return void 0;
+  const info = open[2] ?? "";
+  const result = { source: body.join("\n") };
+  const attribute = /(?:^|\s)(?:title|filename|file)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(info);
+  const filename = attribute ? attribute[1] ?? attribute[2] ?? attribute[3] : void 0;
+  const language = /^(?:title|filename|file)\s*=/.test(info) ? void 0 : /^\{?\.?([A-Za-z0-9_+#.-]+)/.exec(info)?.[1];
+  if (language) result.language = language;
+  if (filename) result.filename = filename;
+  return result;
+}
+function fenceCode(source, language, filename) {
+  const longest = Math.max(2, ...[...source.matchAll(/`+/g)].map((match) => match[0].length));
+  const fence = "`".repeat(longest + 1);
+  const info = [language, filename ? `title="${filename.replaceAll('"', "'")}"` : void 0].filter(Boolean).join(" ");
+  return [`${fence}${info}`, ...source.split(/\r\n|\r|\n/), fence];
+}
+
+export { CONTENT_KEYS, FORMATTING, Loss, OPFConversionError, assertValidOutput, assertValidOwner, clone, concatText, contentKeysOf, fenceCode, hasFormatting, isPlainRun, isRecord, isSlideLike, joinLines, levelsFromIndents, lineIsPlain, linePlain, lineValue, parseCodeFence, parseListLine, parseQuoteLines, plainOf, refuse, report, runText, runsOf, same, splitRuns, splitWhen };