@openpresentation/opf 0.11.3 → 0.12.0

package/README.md

@@ -69,12 +69,28 @@ import type { Presentation, Audience, Tone } from "@openpresentation/opf/types";
 
 The root entry exports every schema, catalog, and validation helper for convenience. Prefer the focused subpaths above when a package consumer only needs one surface, so the root bundle's full catalog/schema payload is not loaded unnecessarily.
 
+### Content conversions
+
+`@openpresentation/opf/convert` converts one payload between text, list, quote, metric, code, timeline, chart, table and a group of metric blocks (`convertContent`, `contentConversionTargets`), nests list items, groups blocks, moves an image between the content and the slide design, and splits or merges slides (`splitSlide`, `splitSlideOnOverflow`, `mergeSlides`, `unpaginate`). Every function is pure, never invents content, reports `lossless` and `loss`, refuses with a reason and validates its output. See the [conversions guide](../../docs/conversions.md). Not in releases before the one that lists it in the changelog.
+
+### Markdown and outlines
+
+`@openpresentation/opf/markdown` reads and writes a deck as Markdown in a small documented dialect (YAML front matter, `---` between slides, `#` title, `##` subtitle, lists, quotes, tables, images, `chart`, `metric` and `timeline` fences, `Note:` speaker notes). `markdownToOpf(markdown, { split, defaults, validate })` returns `{ document, valid, diagnostics, counts }` with lint-shaped diagnostics that carry the line and column of the Markdown; `opfToMarkdown(document, { unsupported })` writes any valid deck, embedding what the dialect has no syntax for as YAML (or dropping it into `report.loss`), and the Markdown it writes converts back to the same deck. Deterministic and offline. Reads front matter with the `yaml` package. See the [Markdown guide](../../docs/markdown.md). Not in releases before the one that lists it in the changelog.
+
+### Design and accessibility audit
+
+`@openpresentation/opf/audit` exports `auditPresentation(document, options)`, `auditSource(source, options)` and `auditRules`: contrast, overflow, type size, alt text, reading order, fonts, links, charts and more, with stable `audit/<rule>` ids in lint's report shape. Read-only and deterministic; see [the audit guide](../../docs/audit.md).
+
 ### Contextual lint (0.10.0)
 
 Version 0.10.0 adds `lintSource(source, options)` and `lintPresentation(document, options)` from `@openpresentation/opf/lint` and the root API. They report strict JSON syntax, duplicate keys, schema constraints, local catalog alternatives, asset registry errors, and explicit host contracts. Source diagnostics retain original UTF-16 ranges without rewriting the document. Options accept already loaded `catalogs` and `contracts`; no remote resources are fetched.
 
 Earlier versions do not include these APIs. See the [lint guide](../../docs/lint.md) for configuration and the source CLI. Passing lint does not certify layout, fonts, or native export fidelity.
 
+### Patch, diff, merge and format (0.12.0)
+
+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 `diffPresentations` (slide matching by id, content and similarity, moves, a readable report and a JSON Patch) and `mergePresentations` (three-way merge with conflict objects that never drop a side); `@openpresentation/opf/format` has `formatPresentation` (canonical key order and layout, idempotent). See [the guide](../../docs/patch-diff-merge-format.md).
+
 ### Layout previews
 
 `@openpresentation/opf/previews` ships pre-rendered HTML thumbnails for the

package/dist/audit.d.ts

@@ -0,0 +1,156 @@
+import { C as CatalogKind } from './catalogs-u6TEeMcz.js';
+import { T as TextMeasurement } from './composition-DWbCiMwF.js';
+import { LintDiagnostic, LintSeverity } from './lint.js';
+import './schemas-BSjlG8-R.js';
+import './validator-bu396ffT.js';
+import './presentation-DRx4hpNZ.js';
+
+/** Same three levels as `lintSource`. */
+type AuditSeverity = LintSeverity;
+type AuditCategory = 'accessibility' | 'design' | 'content';
+/** One JSON Patch operation (RFC 6902 subset) a quick fix applies. Paths are JSON Pointers into the audited document. */
+interface AuditPatchOperation {
+    op: 'add' | 'replace' | 'remove';
+    path: string;
+    value?: unknown;
+}
+/**
+ * A suggested repair. Core never applies it: a host shows it and applies it through its own undoable edit path.
+ * `focus` fixes only name the field the author must fill in; `patch` fixes are small, deterministic and leave
+ * every unrelated field untouched.
+ */
+interface AuditFix {
+    /** Stable id within one diagnostic, such as `focus-alt` or `inherit-text-color`. */
+    id: string;
+    label: string;
+    kind: 'patch' | 'focus';
+    /** True when applying the fix cannot change the meaning of the content (a colour switched to a readable one, a field focused). */
+    safe: boolean;
+    patch?: AuditPatchOperation[];
+    /** For `focus`: the JSON Pointer of the field to edit and a hint of what it is. */
+    focus?: {
+        path: string;
+        field: 'alt' | 'title' | 'text' | 'link' | 'language' | 'fontSize';
+        value?: unknown;
+    };
+}
+interface AuditDiagnostic extends LintDiagnostic {
+    /** `audit/<rule>`; ids are stable across releases. */
+    ruleId: string;
+    /** Zero-based slide index when the finding belongs to one slide. */
+    slide?: number;
+    slideId?: string;
+    category: AuditCategory;
+    /** Measured values behind the finding (ratios, sizes, counts), for reporters and tests. */
+    measured?: Record<string, number | string | boolean | null>;
+    fixes?: AuditFix[];
+}
+interface AuditThresholds {
+    /** Minimum WCAG contrast ratio for normal text. WCAG 2.x AA: 4.5. */
+    contrastNormal: number;
+    /** Minimum ratio for large text (at least 18 pt, or 14 pt bold). WCAG 2.x AA: 3. */
+    contrastLarge: number;
+    /** Smallest rendered text size, in points, before `audit/min-font-size` reports. */
+    minFontSizePt: number;
+    /** Words on one slide above which `audit/slide-word-count` reports. */
+    maxWordsPerSlide: number;
+    /** Distinct font families across the deck above which `audit/font-family-count` reports. */
+    maxFontFamilies: number;
+    /** Minimum effective pixels per inch of an embedded raster image at its displayed size. */
+    minImagePpi: number;
+    /** Largest title offset between slides of the same layout, as a fraction of the slide width/height. */
+    titlePositionTolerance: number;
+    /** Smallest CIE76 colour difference between two chart series (after colour-vision simulation) before they count as confusable. */
+    minSeriesColorDifference: number;
+}
+interface AuditOptions {
+    /** Per-rule severity, or `off`. Keys are full ids (`audit/text-contrast`) or the bare name (`text-contrast`). */
+    rules?: Record<string, AuditSeverity | 'off'>;
+    /** Rules not to run (full ids or bare names). */
+    ignore?: readonly string[];
+    /** When set, run only these rules (full ids or bare names). */
+    only?: readonly string[];
+    /**
+     * Suppress a rule below a JSON Pointer prefix, for one accepted exception, for example
+     * `{rule: 'audit/text-contrast', path: '/slides/3'}`. A prefix matches whole path segments.
+     */
+    ignorePaths?: readonly {
+        rule: string;
+        path: string;
+    }[];
+    thresholds?: Partial<AuditThresholds>;
+    /** Loaded catalog records, consulted after the document's own `catalogs` and before the bundled ones. */
+    catalogs?: Partial<Record<CatalogKind, readonly unknown[]>>;
+    /**
+     * The host's measured fonts. Without it composition uses core's portable estimate; see docs/audit.md.
+     * A function receives the zero-based slide index, so a host can supply a script-aware measurement per slide.
+     */
+    textMeasurement?: TextMeasurement | ((slideIndex: number) => TextMeasurement | undefined);
+    /** Chart series palette (opaque `#RRGGBB`), in the engine's order. Default: the palette opf-render and opf-pptx use. */
+    chartPalette?: readonly string[];
+}
+interface AuditRuleInfo {
+    /** Stable `audit/<name>` id. */
+    id: string;
+    name: string;
+    category: AuditCategory;
+    /** Default severity. */
+    severity: AuditSeverity;
+    summary: string;
+    /** Why the rule exists. */
+    rationale: string;
+    /** The accessibility or design standard it follows, when there is one. */
+    standard?: string;
+    /** What the check cannot see or approximates. */
+    approximations?: string;
+    /** Threshold names (`AuditThresholds`) the rule reads. */
+    thresholds?: (keyof AuditThresholds)[];
+}
+interface AuditReport {
+    /** True when no finding has severity `error` (the same meaning as lint's `valid`). */
+    valid: boolean;
+    /** False when the document failed schema validation, so no design rule was run. */
+    documentValid: boolean;
+    diagnostics: AuditDiagnostic[];
+    counts: Record<AuditSeverity, number>;
+    /** Rule ids that ran, in registry order. */
+    rulesRun: string[];
+    slideCount: number;
+    thresholds: AuditThresholds;
+    checks: {
+        /** `estimated` unless the host supplied `textMeasurement`. */
+        textMeasurement: 'estimated' | 'provided';
+        /** Text contrast is computed against solid, gradient and pattern backgrounds; picture pixels are never read. */
+        backgroundPixels: 'not-read';
+        /** Image resolution reads only embedded `data:` images; URLs are never fetched. */
+        imageBytes: 'embedded-only';
+        nativeExport: 'not-checked';
+    };
+}
+
+/**
+ * The series palette opf-render and opf-pptx draw charts with (`CHART_COLORS`), in series order. A host with
+ * its own palette passes `AuditOptions.chartPalette`.
+ */
+declare const DEFAULT_CHART_PALETTE: readonly string[];
+
+/**
+ * Design and accessibility audit of a presentation: contrast, overflow, minimum type size, alt text,
+ * reading order, titles, fonts, links, charts, placeholders and more. Read-only and deterministic; no
+ * network, clock or model. Each rule has a stable `audit/<name>` id (see docs/audit.md).
+ */
+declare const DEFAULT_AUDIT_THRESHOLDS: Readonly<AuditThresholds>;
+/** Every rule the audit can report, with its default severity, rationale and approximations, in report order. */
+declare const auditRules: readonly AuditRuleInfo[];
+/** The rule a full id (`audit/text-contrast`) or bare name (`text-contrast`) names, or undefined. */
+declare function findAuditRule(name: string): AuditRuleInfo | undefined;
+/**
+ * Audit a parsed presentation. A document that fails schema validation is not audited; its validation
+ * errors come back as `audit/invalid-document` findings. Findings have lint's report shape (rule id,
+ * severity, JSON Pointer path, message, help) plus `slide`, `measured` and suggested `fixes`.
+ */
+declare function auditPresentation(document: unknown, options?: AuditOptions): AuditReport;
+/** Audit JSON source text. Findings carry original-source UTF-16 ranges and one-based line/column, like `lintSource`. */
+declare function auditSource(source: string, options?: AuditOptions): AuditReport;
+
+export { type AuditCategory, type AuditDiagnostic, type AuditFix, type AuditOptions, type AuditPatchOperation, type AuditReport, type AuditRuleInfo, type AuditSeverity, type AuditThresholds, DEFAULT_AUDIT_THRESHOLDS, DEFAULT_CHART_PALETTE, auditPresentation, auditRules, auditSource, findAuditRule };

package/dist/audit.js

@@ -0,0 +1,7 @@
+export { DEFAULT_AUDIT_THRESHOLDS, DEFAULT_CHART_PALETTE, auditPresentation, auditRules, auditSource, findAuditRule } from './chunk-JENJZR3F.js';
+import './chunk-JVTN3HPP.js';
+import './chunk-UQKJWHSS.js';
+import './chunk-6TSDIPSH.js';
+import './chunk-S5W34SIJ.js';
+import './chunk-3ZGSWEHK.js';
+import './chunk-RVN5C2FX.js';

package/dist/{catalogs-CUClB3nl.d.ts → catalogs-u6TEeMcz.d.ts}

@@ -1,4 +1,4 @@
-import { a as SchemaName } from './schemas-X_NniU4A.js';
+import { a as SchemaName } from './schemas-BSjlG8-R.js';
 
 /**
  * Schema for audience records in the pptx.gallery library. Each record names an audience archetype (e.g. 'executives', 'engineering-team', 'investors') and carries seniority, technical-fluency, decision-power, and attention-budget hints used by AI-driven generation. Audiences are referenced from OPF documents via audience; the engine resolves the reference against catalogs.audiences (inline) → catalogs.audiences.source → the default catalog at https://www.pptx.gallery/audiences. The audience field also accepts free-form strings; this catalog is for engine-aware audience archetypes that carry generation hints.

package/dist/catalogs.d.ts

@@ -1,2 +1,2 @@
-export { a as CatalogEntry, b as CatalogIndex, c as CatalogIndexRecord, C as CatalogKind, d as CatalogRecord, i as audiences, j as catalogEntries, k as catalogIndexes, l as catalogKinds, m as catalogSchemaNames, n as catalogs, o as chartTypes, p as colorSchemes, q as fontSchemes, r as languages, s as layouts, t as narratives, u as purposes, v as socialPlatforms, w as themes, x as tones } from './catalogs-CUClB3nl.js';
-import './schemas-X_NniU4A.js';
+export { a as CatalogEntry, b as CatalogIndex, c as CatalogIndexRecord, C as CatalogKind, d as CatalogRecord, i as audiences, j as catalogEntries, k as catalogIndexes, l as catalogKinds, m as catalogSchemaNames, n as catalogs, o as chartTypes, p as colorSchemes, q as fontSchemes, r as languages, s as layouts, t as narratives, u as purposes, v as socialPlatforms, w as themes, x as tones } from './catalogs-u6TEeMcz.js';
+import './schemas-BSjlG8-R.js';

package/dist/catalogs.js

@@ -1 +1,2 @@
-export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-AEUSVEUY.js';
+import './chunk-S5W34SIJ.js';
+export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-3ZGSWEHK.js';

package/dist/{chunk-UDPSGTZI.js → chunk-32DIB5BN.js}

@@ -1,6 +1,6 @@
-import { assertValidPresentation, visitContentPayloads } from './chunk-JCXHSTSM.js';
-import { DEFAULT_FONT_SCHEME, resolveFontSchemeReference, resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries } from './chunk-BVLWFMDX.js';
-import { catalogs } from './chunk-AEUSVEUY.js';
+import { assertValidPresentation } from './chunk-UQKJWHSS.js';
+import { DEFAULT_FONT_SCHEME, resolveFontSchemeReference, resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-6TSDIPSH.js';
+import { catalogs } from './chunk-3ZGSWEHK.js';
 
 // src/pagination.ts
 var OPFPaginationError = class extends Error {
@@ -66,7 +66,8 @@ function leafFor(path, field, value) {
   return leaf;
 }
 function paginateSlide(input, options = {}) {
-  assertValidPresentation({ slides: [input] });
+  const deckReferences = options.presentation?.references;
+  assertValidPresentation({ ...Array.isArray(deckReferences) ? { references: deckReferences } : {}, slides: [input] });
   let source = clone(input);
   const maxSlides = options.maxSlides ?? 100;
   if (!Number.isInteger(maxSlides) || maxSlides < 1 || maxSlides > 1e4) throw new RangeError("maxSlides must be an integer between 1 and 10000.");
@@ -95,6 +96,7 @@ function paginateSlide(input, options = {}) {
     return composeSlide(withReadability(slide, true), { ...options, slideNumber: (options.slideNumber ?? sourceIndex + 1) + pageIndex });
   };
   const initial = geometry(source);
+  const fit = (diagnostics) => diagnostics.filter((issue) => issue.code === "text-overflow" || issue.code === "small-cell" || !!initial.furniture?.diagnostics.includes(issue));
   const repeatedMappings = (pageIndex) => {
     if (!initial.furniture) return [];
     const paths = new Set(initial.items.filter((item) => headingFields.has(item.field)).map((item) => item.path));
@@ -104,7 +106,7 @@ function paginateSlide(input, options = {}) {
     }
     return [...paths].map((sourcePath) => ({ sourcePath, outputPath: sourcePath.startsWith(`${sourceBase}.`) ? `slides.${sourceIndex + pageIndex}${sourcePath.slice(sourceBase.length)}` : sourcePath }));
   };
-  if (!initial.diagnostics.length) return { slides: [source], pages: [{ slideIndex: sourceIndex, mappings: initial.items.map((item) => ({ sourcePath: item.path, outputPath: item.path })), ...initial.furniture ? { repeatedMappings: repeatedMappings(0) } : {} }] };
+  if (!fit(initial.diagnostics).length) return { slides: [source], pages: [{ slideIndex: sourceIndex, mappings: initial.items.map((item) => ({ sourcePath: item.path, outputPath: item.path })), ...initial.furniture ? { repeatedMappings: repeatedMappings(0) } : {} }] };
   const headerIssues = initial.diagnostics.filter((issue) => headingFields.has(issue.path.slice(sourceBase.length + 1)) || initial.furniture?.diagnostics.includes(issue));
   if (headerIssues.length) throw new OPFPaginationError("Repeated headings or header/footer content cannot fit or resolve. Change the repeated content or slide design before pagination.", headerIssues);
   const leaves = initial.items.filter((item) => !headingFields.has(item.field)).map((item) => leafFor(item.path, item.field, item.value));
@@ -142,7 +144,7 @@ function paginateSlide(input, options = {}) {
         if (leafPaths.has(childPath)) {
           const portion = portions.get(childPath);
           if (portion) {
-            result[key] = clone(portion.value);
+            result[key] = clone(portion.leaf.unit === "items" && portion.start > 0 && (key === "items" || key === "bullets") && node.numbering !== void 0 ? sliceNumberedItems(portion.leaf.value, node.numbering, portion.start, portion.end) : portion.value);
             hasContent = true;
             mappings.push({ sourcePath: childPath, outputPath, ...portion.leaf.unit ? { range: { unit: portion.leaf.unit, start: portion.start, end: portion.end } } : {} });
           }
@@ -170,15 +172,16 @@ function paginateSlide(input, options = {}) {
     if (pageIndex > 0) delete slide.notes;
     return { slide, mappings };
   };
-  const diagnosticsFor = (portions) => geometry(project(portions, slides.length).slide, slides.length).diagnostics;
+  const diagnosticsFor = (portions) => fit(geometry(project(portions, slides.length).slide, slides.length).diagnostics);
   const finish = () => {
     if (!selected.size) return;
     if (slides.length >= maxSlides) throw new OPFPaginationError(`Pagination needs more than ${maxSlides} slides. No partial result was returned.`);
     const { slide, mappings } = project(selected, slides.length);
-    const issues = geometry(slide, slides.length).diagnostics;
+    const issues = fit(geometry(slide, slides.length).diagnostics);
     if (issues.length) throw new OPFPaginationError("A continuation page does not fit at its final page number. No partial result was returned.", issues);
     assignPageIds(slide, slides.length);
-    assertValidPresentation({ slides: [slide] });
+    const references = options.presentation?.references;
+    assertValidPresentation({ ...Array.isArray(references) ? { references } : {}, slides: [slide] });
     slides.push(slide);
     pages.push({ slideIndex: sourceIndex + slides.length - 1, mappings, ...initial.furniture ? { repeatedMappings: repeatedMappings(slides.length - 1) } : {} });
     selected = /* @__PURE__ */ new Map();

package/dist/chunk-4FWCY4ZV.js

@@ -0,0 +1,198 @@
+import { validatePresentation } from './chunk-UQKJWHSS.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 };