@openpresentation/opf 0.12.2 → 0.14.0

package/dist/chart-data-B_3z9VTb.d.ts

@@ -0,0 +1,188 @@
+/** A scalar data cell (chart data, dataset rows). */
+type DataCellValue = string | number | boolean | null;
+/** A named column with an optional number format. The string column form is `{ name }` with no format. */
+interface DataColumn {
+    name: string;
+    format?: string;
+}
+/** Provenance of inline data or a dataset. Engines never read, fetch or refresh it. */
+interface DataSourceRef {
+    src: string;
+    sheet?: string;
+    range?: string;
+    fields?: string[];
+    retrieved?: string;
+    description?: string;
+}
+/** One shared data table in the top-level `datasets` map. */
+interface Dataset {
+    title?: string;
+    description?: string;
+    columns: (string | DataColumn)[];
+    rows: DataCellValue[][];
+    source?: DataSourceRef;
+}
+/** Chart data (or, as `{ dataset, fields }`, a table) taken from a top-level dataset. */
+interface DatasetRef {
+    dataset: string;
+    fields?: string[];
+}
+/** `chart.mapping`: the category, X and series columns by name (after any `fields` selection). */
+interface ChartMapping {
+    category?: string;
+    x?: string;
+    series?: string[];
+}
+/** One series of a combo chart: drawn as a clustered column or as a line with markers, against the primary (left) or secondary (right) value axis. */
+interface ChartComboSeries {
+    role: 'bar' | 'line';
+    axis: 'primary' | 'secondary';
+}
+/** A text run as table cells and headers hold them (see the schema `TextRun`). */
+type DataTextRun = string | {
+    text: string;
+    [key: string]: unknown;
+};
+/** A table cell's value: a scalar or rich runs. */
+type DataTableValue = string | number | boolean | null | DataTextRun[];
+/** A styled or spanning table cell, optionally with a number format. */
+interface DataStyledCell {
+    value: DataTableValue;
+    style?: Record<string, unknown>;
+    colSpan?: number;
+    rowSpan?: number;
+    format?: string;
+}
+/** A table body cell. */
+type DataTableCell = DataTableValue | DataStyledCell;
+/** A table column header: a cell, or a DataColumn. */
+type DataTableHeader = DataTableCell | DataColumn;
+type DataDiagnosticCode = 'chart-value-not-numeric' | 'dataset-unknown' | 'dataset-field-unknown' | 'data-column-duplicate' | 'chart-mapping-unknown-column' | 'chart-mapping-adapted' | 'chart-highlight-unknown-name' | 'chart-highlight-adapted' | 'number-format-invalid';
+interface DataDiagnostic {
+    code: DataDiagnosticCode;
+    severity: 'error' | 'warning';
+    /** JSON Pointer of the offending value: below the `path` option for the chart or table, or into `/datasets/<id>`. */
+    path: string;
+    message: string;
+}
+interface DataResolveOptions {
+    /** JSON Pointer of the chart or table object, used as the base of diagnostic paths. Default: "" (paths start at `/data` or `/rows`). */
+    path?: string;
+}
+type ResolvedChartData = {
+    ok: true;
+    /** Column names in canonical order: category, then (scatter only) X, then every series. */
+    columns: string[];
+    /**
+     * True when `columns[1]` is the X column: an XY chart with three or more resolved columns. An XY chart with two
+     * columns has no X column; its second column is the one series, plotted against row numbers (the legacy rule).
+     */
+    hasX: boolean;
+    /** The number format of each column (from its DataColumn), aligned with `columns`. */
+    formats: (string | undefined)[];
+    /** Category cells as authored; X and series cells (and a lone column, which has no category) passed through `chartNumber` (null is a gap). */
+    rows: DataCellValue[][];
+    source?: DataSourceRef;
+    /** The dataset id when the chart references one. */
+    dataset?: string;
+    /**
+     * Combo charts only (FA-15): how each series is drawn, aligned with the series columns (`columns.slice(1)`). The series
+     * are ordered column series first, then the line series on the primary axis, then those on the secondary axis, each in
+     * plotted order, so every engine draws, exports and lists them in the legend alike.
+     */
+    combo?: ChartComboSeries[];
+    diagnostics: DataDiagnostic[];
+} | {
+    ok: false;
+    reason: 'dataset-unknown' | 'no-rows' | 'no-columns';
+    message: string;
+    diagnostics: DataDiagnostic[];
+};
+interface ResolvedTableData {
+    /** Headers as authored (dataset tables: the dataset's columns after `fields`), or undefined for a table without headers. */
+    columns?: DataTableHeader[];
+    rows: DataTableCell[][];
+    /** The column number formats (DataColumn or header StyledTableCell `format`), by column index. */
+    formats: (string | undefined)[];
+    /** The dataset id when the table references one. */
+    dataset?: string;
+    diagnostics: DataDiagnostic[];
+}
+/**
+ * Strict chart number: finite numbers, and strings in strict decimal syntax (trimmed). Everything else is null (a gap):
+ * `"12%"`, `"$5"`, `"(5)"`, `"1,234"`, `"1.234,5"`, `"Q1"`, `""`, booleans and null. A plain digit string beyond the safe
+ * integer range is a gap too, as in data import (it is usually an identifier that would lose digits); a decimal or exponent
+ * form such as `"1e20"` is a number.
+ */
+declare function chartNumber(value: unknown): number | null;
+/** Why a NumberFormat is invalid, or undefined for a valid one. An absent format is valid (General). */
+declare function numberFormatError(format: unknown): string | undefined;
+/** Format a number with a NumberFormat; an absent or invalid format prints the General form (String(value)). */
+declare function formatDataNumber(value: number, format?: string): string;
+/** NumberFormat -> Excel format code ("General" when absent or invalid). Literal prefix/suffix text is quoted or escaped; placeholders are written '#' before '0' ("0#" -> "#0"). */
+declare function toExcelNumberFormat(format?: string): string;
+/** Excel format code -> NumberFormat, or undefined when the code has no exact NumberFormat equivalent (General, sections, scaling commas, and placeholder orders Excel reads by position such as "0#" or "0.#0"). */
+declare function fromExcelNumberFormat(code: string): string | undefined;
+/** True when the value is a dataset reference (`{ dataset: "<id>" }`). */
+declare function isDatasetRef(value: unknown): value is DatasetRef;
+/** Diagnostics of the top-level datasets themselves: duplicate column names and invalid column formats. */
+declare function datasetDiagnostics(document: unknown): DataDiagnostic[];
+/**
+ * Pure: a copy of the document where every chart and table DatasetRef is replaced by inline data (columns as
+ * DataColumn when a format applies, rows copied; a chart also takes the dataset's `source`). `datasets` stays in
+ * place. Unknown ids (and references naming an unknown field) are left as they are.
+ */
+declare function inlineDatasets<T>(document: T): T;
+/** A table in inline form: a dataset-backed table is copied from the document's dataset; anything else is returned as is. */
+declare function inlineTableData<T>(table: T, document?: unknown): T;
+/** A chart in inline form: a dataset reference in `data` is copied from the document's dataset; anything else is returned as is. */
+declare function inlineChartData<T>(chart: T, document?: unknown): T;
+/** The ids of top-level datasets that no chart or table references, in declaration order. */
+declare function unusedDatasets(document: unknown): string[];
+/** True for a chart type with an X value axis (scatter; deprecated ids resolve through their replacement first). */
+declare function isXYChartType(type: unknown): boolean;
+/**
+ * Resolve a chart's data to the canonical positional table: [category, (x,) ...series].
+ * Category cells are kept as authored; X and series cells pass through chartNumber.
+ * Inline ChartData, a DatasetRef (needs the document) and mapping are resolved here.
+ */
+declare function resolveChartData(chart: unknown, document?: unknown, options?: DataResolveOptions): ResolvedChartData;
+/** One JSON Patch `replace` operation of a ChartNumberFix. */
+interface ChartNumberFixOperation {
+    op: 'replace';
+    path: string;
+    value: unknown;
+}
+/** A fix for a chart value column whose text cells all share one display style (`"12%"`, `"$1,234"`, `"1,234.5"`). */
+interface ChartNumberFix {
+    /**
+     * JSON Patch: one `replace` per text cell (with its number), then one for the column (a DataColumn with `format`).
+     * Paths are those of the `chart-value-not-numeric` diagnostics: below `options.path` for inline data, or into
+     * `/datasets/<id>` for a dataset (which every chart and table that uses it shares; their text is unchanged).
+     */
+    patches: ChartNumberFixOperation[];
+    /** Index of the column in the authored columns (`chart.data.columns`, or the dataset's columns). */
+    column: number;
+    /** The column name. */
+    name: string;
+    /** The NumberFormat that displays every number of the column exactly as its text was written. */
+    format: string;
+}
+interface ChartNumberFixOptions extends DataResolveOptions {
+    /** The column to fix, by authored index or name. Default: the first value column that has a fix. */
+    column?: number | string;
+}
+/**
+ * Migration help for the strict number rule: when every text cell of a chart value column is written in one display
+ * style that a NumberFormat reproduces exactly (`"12%"`/`"8.5%"` -> 0.12/0.085 with `0.#%`; `"$1,234"` -> 1234 with
+ * `$#,##0`; `"1,234"` -> 1234 with `#,##0`), the patch that stores the numbers and gives the column that format.
+ * Undefined when there is nothing to fix or no exact fix: mixed styles, accounting negatives `(5)`, `1.234,5`, units,
+ * a column that already has a format, or any value the format would display differently (number cells included).
+ */
+declare function suggestChartNumberFix(chart: unknown, document?: unknown, options?: ChartNumberFixOptions): ChartNumberFix | undefined;
+/** Resolve a table (inline or dataset-backed) to headers, rows and per-column formats. */
+declare function resolveTableData(table: unknown, document?: unknown, options?: DataResolveOptions): ResolvedTableData;
+/** Display value of a table cell: a number with a format (cell, else column) becomes formatted text; anything else is returned unchanged. */
+declare function tableCellDisplayValue(cell: DataTableCell, columnFormat?: string): DataTableCell;
+
+export { resolveChartData as A, resolveTableData as B, type ChartMapping as C, type DataCellValue as D, suggestChartNumberFix as E, tableCellDisplayValue as F, toExcelNumberFormat as G, unusedDatasets as H, type ChartComboSeries as I, type ResolvedChartData as R, type ChartNumberFix as a, type ChartNumberFixOperation as b, type ChartNumberFixOptions as c, type DataColumn as d, type DataDiagnostic as e, type DataDiagnosticCode as f, type DataResolveOptions as g, type DataSourceRef as h, type DataStyledCell as i, type DataTableCell as j, type DataTableHeader as k, type DataTableValue as l, type DataTextRun as m, type Dataset as n, type DatasetRef as o, type ResolvedTableData as p, chartNumber as q, datasetDiagnostics as r, formatDataNumber as s, fromExcelNumberFormat as t, inlineChartData as u, inlineDatasets as v, inlineTableData as w, isDatasetRef as x, isXYChartType as y, numberFormatError as z };

package/dist/chunk-4LDGKLUC.js

@@ -0,0 +1,192 @@
+import { isRecord, same } from './chunk-CSQHPVGL.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-V2537ENL.js → chunk-4VJDTF55.js}

@@ -1,92 +1,4 @@
-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)]);
-}
+import { runText } from './chunk-CSQHPVGL.js';
 
 // src/convert/text-lines.ts
 var LIST_PREFIX = /^([ \t]*)(?:([-*•+]|\d{1,3}[.)])[ \t]+)?/;
@@ -195,4 +107,4 @@ function fenceCode(source, language, filename) {
   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 };
+export { fenceCode, levelsFromIndents, parseCodeFence, parseListLine, parseQuoteLines, splitWhen };

package/dist/chunk-5ZU6JAPP.js

@@ -0,0 +1,83 @@
+import { presentation } from './chunk-LS2FMPI5.js';
+
+// src/format.ts
+var OPFFormatError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OPFFormatError";
+  }
+};
+var root = presentation;
+var flattenCache = /* @__PURE__ */ new WeakMap();
+function collect(schema, seen) {
+  if (!schema || typeof schema !== "object" || seen.has(schema)) return [];
+  seen.add(schema);
+  const node = schema;
+  const out = [node];
+  if (typeof node.$ref === "string" && node.$ref.startsWith("#/$defs/")) out.push(...collect(root.$defs?.[node.$ref.slice("#/$defs/".length)], seen));
+  for (const list of [node.oneOf, node.anyOf, node.allOf]) for (const branch of list ?? []) out.push(...collect(branch, seen));
+  out.push(...collect(node.then, seen), ...collect(node.else, seen));
+  return out;
+}
+function flatten(schema) {
+  if (!schema || typeof schema !== "object") return [];
+  const cached = flattenCache.get(schema);
+  if (cached) return cached;
+  const nodes = collect(schema, /* @__PURE__ */ new Set());
+  flattenCache.set(schema, nodes);
+  return nodes;
+}
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function arrange(value, schemas) {
+  if (Array.isArray(value)) {
+    const itemSchemas = schemas.flatMap((node) => node.items && typeof node.items === "object" ? flatten(node.items) : []);
+    return value.map((item) => arrange(item, itemSchemas));
+  }
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const declared = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of schemas) for (const key of Object.keys(node.properties ?? {})) if (!seen.has(key)) {
+    seen.add(key);
+    declared.push(key);
+  }
+  const present = Object.keys(record);
+  const ordered = [...declared.filter((key) => own(record, key)), ...present.filter((key) => !seen.has(key))];
+  const out = {};
+  for (const key of ordered) {
+    let children = schemas.flatMap((node) => node.properties && own(node.properties, key) ? flatten(node.properties[key]) : []);
+    if (!children.length && !seen.has(key)) children = schemas.flatMap((node) => node.additionalProperties && typeof node.additionalProperties === "object" ? flatten(node.additionalProperties) : []);
+    Object.defineProperty(out, key, { value: arrange(record[key], children), enumerable: true, configurable: true, writable: true });
+  }
+  return out;
+}
+function sortPresentationKeys(document) {
+  return arrange(document, flatten(root));
+}
+function format(input, options = {}) {
+  let document = input;
+  if (typeof input === "string") {
+    try {
+      document = JSON.parse(input.replace(/^/u, ""));
+    } catch (error) {
+      throw new OPFFormatError(`Invalid JSON: ${error.message}`);
+    }
+  }
+  const indent = options.indent ?? 2;
+  if (!Number.isInteger(indent) || indent < 0 || indent > 8) throw new OPFFormatError("indent must be an integer from 0 to 8.");
+  if (options.eol !== void 0 && options.eol !== "lf" && options.eol !== "crlf") throw new OPFFormatError("eol must be lf or crlf.");
+  const text = JSON.stringify(sortPresentationKeys(document), null, indent);
+  if (text === void 0) throw new OPFFormatError("Nothing to format.");
+  return options.eol === "crlf" ? `${text.replaceAll("\n", "\r\n")}\r
+` : `${text}
+`;
+}
+function isFormatted(source, options = {}) {
+  try {
+    return format(source, options) === source;
+  } catch {
+    return false;
+  }
+}
+
+export { OPFFormatError, format, isFormatted, sortPresentationKeys };