@openpresentation/opf 0.26.0 → 0.26.2

package/dist/{chunk-P7S3ORB4.js → chunk-LUQYSUXS.js}

@@ -1,5 +1,5 @@
 import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, normalizeColorVariant, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, defaultSlideBackground, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-XRMV2GMB.js';
-import { schemas, schemaEntries } from './chunk-F4HFDP6I.js';
+import { schemas, schemaEntries } from './chunk-N6CNJCIF.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
@@ -1311,8 +1311,8 @@ function colorChoice(levels, scheme, variables = {}) {
     const variant = normalizeColorVariant(level.variant);
     if (variant) {
       const fill = definition !== void 0 && !variantOnly && !themeSlot && !isPicture ? decisionColor(definition, scheme, variables) : void 0;
-      const own2 = definition !== void 0 && !variantOnly && !themeSlot;
-      return { variant, ...fill ? { background: fill } : {}, drawn: variantOnly ? picture : { definition: own2 ? definition : void 0 } };
+      const own4 = definition !== void 0 && !variantOnly && !themeSlot;
+      return { variant, ...fill ? { background: fill } : {}, drawn: variantOnly ? picture : { definition: own4 ? definition : void 0 } };
     }
     if (variantOnly || definition === void 0 || definition === null || definition === false) continue;
     if (themeSlot) return { variant: { background: themeSlot } };
@@ -1328,20 +1328,20 @@ function colorChoice(levels, scheme, variables = {}) {
   return {};
 }
 function resolveDesign(document, index, context) {
-  const deck = rec(document.design), own2 = rec(rec(rec(document.slides)[index]).design);
+  const deck = rec(document.design), own4 = rec(rec(rec(document.slides)[index]).design);
   const { options, diagnostics, resolved } = context;
   const { theme, colorScheme, fontScheme, fontSchemePath } = resolved;
   const fontPath = `/${fontSchemePath.split(".").join("/")}`;
   const fontDiagnostic = diagnostics.find((diagnostic) => diagnostic.kind === "fontSchemes");
   const dimensions = { width: options.width, height: options.height };
   const variables = rec(document.variables);
-  const choice = colorChoice([own2, deck, theme], colorScheme, variables);
+  const choice = colorChoice([own4, deck, theme], colorScheme, variables);
   const roles = resolveColorRoles(colorScheme, { background: choice.background, variant: choice.variant });
   const dark = roles.dark;
   const text = roles.text;
-  const backdrop = backdropOf(choice.drawn ? choice.drawn.definition : own2.background ?? deck.background ?? theme.background, colorScheme, text, variables, roles.map.bg1 === "light1" ? void 0 : roles.background);
-  const picture = imageBackground(choice.drawn ? choice.drawn.definition : own2.background ?? deck.background ?? theme.background);
-  const backgroundImage = picture && own2.background !== void 0 ? { source: picture.src, fit: picture.fit, path: `/slides/${index}/design/background` } : picture && deck.background !== void 0 ? { source: picture.src, fit: picture.fit, path: "/design/background" } : void 0;
+  const backdrop = backdropOf(choice.drawn ? choice.drawn.definition : own4.background ?? deck.background ?? theme.background, colorScheme, text, variables, roles.map.bg1 === "light1" ? void 0 : roles.background);
+  const picture = imageBackground(choice.drawn ? choice.drawn.definition : own4.background ?? deck.background ?? theme.background);
+  const backgroundImage = picture && own4.background !== void 0 ? { source: picture.src, fit: picture.fit, path: `/slides/${index}/design/background` } : picture && deck.background !== void 0 ? { source: picture.src, fit: picture.fit, path: "/design/background" } : void 0;
   return {
     theme,
     colorScheme,
@@ -1525,8 +1525,8 @@ function runsOf(tv) {
   }));
 }
 function altOf(value, assets) {
-  const own2 = typeof value === "object" && value !== null ? value.alt : void 0;
-  if (typeof own2 === "string") return own2;
+  const own4 = typeof value === "object" && value !== null ? value.alt : void 0;
+  if (typeof own4 === "string") return own4;
   let source = typeof value === "string" ? value : rec(value).src;
   for (let hop = 0; typeof source === "string" && source.startsWith("asset:") && hop < 8; hop++) {
     const entry = rec(assets)[source.slice(6)];
@@ -2695,7 +2695,7 @@ var formatRules = [
     "error",
     "The text is not strict JSON.",
     "Every OPF tool reads JSON. A misplaced comma, quote, comment or trailing comma makes the file unreadable, and the range says where.",
-    { cost: "syntax", standard: "RFC 8259 (strict JSON: no comments, no trailing commas)", approximations: "Only text input is checked. A string is always read as JSON; a text that looks like YAML or Markdown gets a hint to use fromYaml or fromMarkdown first." }
+    { cost: "syntax", standard: "RFC 8259 (strict JSON: no comments, no trailing commas)", approximations: "Only text input is checked. A string is always read as JSON. One finding per root cause, in position order and at most five (a key with no value, a missing comma, a bracket never closed; not the damage each one causes further on): `message` says what is wrong, `help` what to do next and `location` is the range to underline. A text that looks like YAML or Markdown gets one finding with a hint to use fromYaml or fromMarkdown first. Source editors get the same causes with their quick fixes from analyzeJsonSyntax (@openpresentation/opf/source)." }
   ),
   rule(
     "duplicate-key",
@@ -2932,6 +2932,7 @@ function issueFinding(issue2, ruleId = issueRuleId(issue2), schemaName = "presen
   else if (issue2.keyword === "opf")
     help = "Resolve the reported structural conflict while preserving every content field. Preview the result after editing.";
   const allowed = Array.isArray(issue2.params.allowedValues) ? issue2.params.allowedValues.filter(primitive) : [];
+  const nearest = issue2.keyword === "additionalProperties" ? nearestProperties(issue2, entry.schema, precise?.pointer, precise?.schemaName) : [];
   return finding(ruleId, {
     ...severity ? { severity } : {},
     path,
@@ -2948,9 +2949,29 @@ function issueFinding(issue2, ruleId = issueRuleId(issue2), schemaName = "presen
         origin: "schema",
         definition
       }))
-    } : {}
+    } : nearest.length ? { suggestions: nearest } : {}
   });
 }
+var NEAREST_PROPERTIES = 3;
+function nearestProperties(issue2, fallbackRoot, pointerToKeyword, schemaName) {
+  const typed = issue2.params.additionalProperty;
+  if (typeof typed !== "string" || pointerToKeyword === void 0) return [];
+  const rootEntry = schemaEntries.find((entry) => entry.name === schemaName);
+  let node = rootEntry?.schema ?? fallbackRoot;
+  const base = pointerToKeyword.split("/").slice(0, -1);
+  for (const token of base.slice(1)) {
+    if (!isRecord(node)) return [];
+    node = node[token.replaceAll("~1", "/").replaceAll("~0", "~")];
+  }
+  if (!isRecord(node) || !isRecord(node.properties)) return [];
+  const root = rootEntry?.schema ?? fallbackRoot, limit = typed.length <= 3 ? 1 : 2, lower = typed.toLowerCase();
+  return Object.keys(node.properties).map((name) => ({ name, away: distance(lower, name.toLowerCase()) })).filter(({ name, away }) => name !== typed && away <= limit).sort((a, b) => a.away - b.away || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)).slice(0, NEAREST_PROPERTIES).map(({ name }) => ({
+    value: name,
+    label: name,
+    origin: "schema",
+    definition: `${String(root.$id)}#${base.join("/")}/properties/${name.replaceAll("~", "~0").replaceAll("/", "~1")}`
+  }));
+}
 function resolve(cursor, seen = /* @__PURE__ */ new Set()) {
   const ref = cursor.schema.$ref;
   if (typeof ref !== "string") return cursor;
@@ -3224,7 +3245,7 @@ function variableFindings(document, engine, schemaValid) {
       })
     );
   if (engine.template !== void 0 || !schemaValid) return findings;
-  const walk = (value, path, depth2) => {
+  const walk2 = (value, path, depth2) => {
     if (depth2 > 64) return;
     if (typeof value === "string") {
       if (value.startsWith("data:") || !value.includes("{{")) return;
@@ -3242,17 +3263,17 @@ function variableFindings(document, engine, schemaValid) {
     }
     if (Array.isArray(value)) {
       value.forEach((entry, index) => {
-        walk(entry, [...path, String(index)], depth2 + 1);
+        walk2(entry, [...path, String(index)], depth2 + 1);
       });
       return;
     }
     if (value && typeof value === "object")
       for (const [key2, entry] of Object.entries(value)) {
         if (path.length === 0 && ["variables", "extensions", "catalogs", "assets"].includes(key2)) continue;
-        walk(entry, [...path, key2], depth2 + 1);
+        walk2(entry, [...path, key2], depth2 + 1);
       }
   };
-  walk(document, [], 0);
+  walk2(document, [], 0);
   return findings;
 }
 function undeclaredCatalogFindings(document) {
@@ -3475,15 +3496,1728 @@ function contractFindings(document, contracts) {
   }
   return findings;
 }
+
+// src/patch.ts
+var OPFPatchError = 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 = "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 OPFPatchValidationError = class extends OPFPatchError {
+  validation;
+  constructor(validation) {
+    super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
+    this.name = "OPFPatchValidationError";
+    this.validation = validation;
+  }
+};
+var own2 = (value, key2) => Object.prototype.hasOwnProperty.call(value, key2);
+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((key2) => own2(right, key2) && jsonEqual(left[key2], right[key2]));
+}
+function escapePointerToken(token) {
+  return String(token).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function unescapePointerToken(token) {
+  return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function parsePointer(pointer4) {
+  if (typeof pointer4 !== "string" || pointer4 !== "" && !pointer4.startsWith("/") || /~(?![01])/u.test(pointer4)) {
+    throw new OPFPatchError("invalid-json-pointer", "Expected a JSON Pointer (empty string or /path with ~0 and ~1 escapes).", { path: typeof pointer4 === "string" ? pointer4 : void 0 });
+  }
+  return pointer4 === "" ? [] : pointer4.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 OPFPatchError("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 splitPointer2(pointer4) {
+  const tokens = parsePointer(pointer4);
+  if (!tokens.length) throw new OPFPatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer4 });
+  return { parent: formatPointer(tokens.slice(0, -1)), token: tokens[tokens.length - 1] };
+}
+function readPointer(document, pointer4) {
+  const tokens = typeof pointer4 === "string" ? parsePointer(pointer4) : pointer4;
+  let value = document;
+  for (const token of tokens) {
+    if (Array.isArray(value)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { found: false };
+      const at2 = Number(token);
+      if (!Number.isSafeInteger(at2) || at2 >= value.length) return { found: false };
+      value = value[at2];
+    } else if (value && typeof value === "object" && own2(value, token)) value = value[token];
+    else return { found: false };
+  }
+  return { found: true, value };
+}
+function getAtPointer(document, pointer4) {
+  const result = readPointer(document, pointer4);
+  if (!result.found) {
+    const shown = typeof pointer4 === "string" ? pointer4 : formatPointer(pointer4);
+    throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${shown || "/"}`, { path: shown });
+  }
+  return result.value;
+}
+var hasPointer = (document, pointer4) => readPointer(document, pointer4).found;
+function arrayIndex(token, length, allowEnd, path) {
+  if (allowEnd && token === "-") return length;
+  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
+  const at2 = Number(token);
+  if (!Number.isSafeInteger(at2) || at2 > length || !allowEnd && at2 >= length) throw new OPFPatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
+  return at2;
+}
+function normalizePatch(patch) {
+  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 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)) {
+    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 (!own2(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 key2 = tokens[tokens.length - 1];
+  const found = readPointer(document, tokens.slice(0, -1));
+  if (!found.found || !found.value || typeof found.value !== "object") {
+    throw new OPFPatchError("patch-parent-missing", `Patch parent does not exist for ${path}.`, { path });
+  }
+  return { parent: found.value, key: key2 };
+}
+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: key2 } = parentOf(document, tokens, path);
+  if (Array.isArray(parent)) {
+    const at2 = arrayIndex(key2, parent.length, true, path);
+    parent.splice(at2, 0, clone(value));
+    return { document, inverse: { op: "remove", path: formatPointer([...tokens.slice(0, -1), at2]) } };
+  }
+  const record = parent;
+  const previous = own2(record, key2) ? record[key2] : NONE;
+  Object.defineProperty(record, key2, { 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: key2 } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at2 = arrayIndex(key2, parent.length, false, path);
+    previous = parent[at2];
+    parent[at2] = clone(value);
+  } else {
+    const record = parent;
+    if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+    previous = record[key2];
+    Object.defineProperty(record, key2, { 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 OPFPatchError("patch-root-remove", "The document root cannot be removed.", { path });
+  const { parent, key: key2 } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at2 = arrayIndex(key2, parent.length, false, path);
+    previous = parent[at2];
+    parent.splice(at2, 1);
+    return { document, inverse: { op: "add", path: formatPointer([...tokens.slice(0, -1), at2]), value: clone(previous) } };
+  }
+  const record = parent;
+  if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+  previous = record[key2];
+  delete record[key2];
+  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 OPFPatchError("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 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);
+      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 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 = { presentation: working, inverse, patch: operations };
+  if (options.validate) {
+    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 && 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).presentation;
+}
+function invertPatch(document, patch) {
+  return applyPatchWithInverse(document, patch).inverse;
+}
+
+// src/schema-navigation.ts
+var own3 = (object2, key2) => object2 !== null && typeof object2 === "object" && Object.hasOwn(object2, key2);
+var documents = new Map(Object.values(schemas).map((schema) => [schema.$id, schema]));
+var presentationSchema = schemas.presentation;
+function splitOpfPath(path) {
+  if (Array.isArray(path)) return path.map((segment) => String(segment));
+  if (typeof path !== "string") throw new TypeError("An OPF path must be a string or an array of segments.");
+  if (path === "") return [];
+  if (path.startsWith("/")) return parsePointer(path);
+  return path.split(".").filter(Boolean);
+}
+function readSchemaPointer(target, pointer4) {
+  let current = target;
+  for (const token of parsePointer(pointer4)) {
+    if (current === null || typeof current !== "object" || !own3(current, token)) return void 0;
+    current = current[token];
+  }
+  return current;
+}
+function absolutize(schema, id) {
+  if (Array.isArray(schema)) return schema.map((item) => absolutize(item, id));
+  if (schema === null || typeof schema !== "object") return schema;
+  const copy = {};
+  for (const [key2, value] of Object.entries(schema)) copy[key2] = key2 === "$ref" && typeof value === "string" && value.startsWith("#") ? `${id}${value}` : absolutize(value, id);
+  return copy;
+}
+function mergeAllOf(schema, root, seen) {
+  if (!Array.isArray(schema.allOf)) return schema;
+  const { allOf, ...base } = schema;
+  let merged = base;
+  for (const member of allOf) {
+    const resolved = resolveSchema(member, root, new Set(seen));
+    if (!resolved.properties && !resolved.type && !resolved.oneOf && !resolved.anyOf) continue;
+    merged = {
+      ...resolved,
+      ...merged,
+      ...resolved.properties || merged.properties ? { properties: { ...resolved.properties, ...merged.properties } } : {}
+    };
+  }
+  return merged;
+}
+function resolveSchema(schema, root = presentationSchema, seen = /* @__PURE__ */ new Set()) {
+  if (!schema || typeof schema !== "object") return {};
+  if (!schema.$ref) return mergeAllOf(schema, root, seen);
+  const ref = schema.$ref;
+  if (seen.has(ref)) return {};
+  seen.add(ref);
+  const [id = "", fragment = ""] = ref.split("#");
+  const target = id ? documents.get(id) : root;
+  if (!target) throw new Error(`Unresolved OPF schema: ${ref}`);
+  let resolved = fragment ? readSchemaPointer(target, fragment) : target;
+  if (!resolved) throw new Error(`Unresolved OPF schema: ${ref}`);
+  if (id && target !== root) resolved = absolutize(resolved, id);
+  const { $ref: _ref, ...rest } = schema;
+  return mergeAllOf({ ...resolveSchema(resolved, target, seen), ...rest }, target, seen);
+}
+function schemaVariants(schema, root = presentationSchema) {
+  const resolved = resolveSchema(schema, root);
+  if (Array.isArray(resolved.type)) return resolved.type.flatMap((type) => schemaVariants({ ...resolved, type }, root));
+  const variants = resolved.oneOf ?? resolved.anyOf;
+  if (!variants) return [resolved];
+  const { $ref: _ref, oneOf: _oneOf, anyOf: _anyOf, ...base } = resolved;
+  return variants.flatMap(
+    (child) => schemaVariants(child, root).map((variant) => {
+      const requiredOnly = !variant.type && !variant.properties && !variant.$ref && Array.isArray(variant.required);
+      return {
+        ...base,
+        ...variant,
+        properties: base.properties || variant.properties ? { ...base.properties, ...variant.properties } : void 0,
+        ...base.required || variant.required ? { required: [.../* @__PURE__ */ new Set([...base.required ?? [], ...variant.required ?? []])] } : {},
+        ...requiredOnly && !variant.title ? { title: variant.required.join(" + ") } : {}
+      };
+    })
+  );
+}
+function schemaType(schema, value) {
+  return schema.type ?? (schema.properties || schema.additionalProperties ? "object" : schema.items ? "array" : schema.const !== void 0 ? typeof schema.const : value === null ? "null" : Array.isArray(value) ? "array" : typeof value === "undefined" ? "string" : typeof value);
+}
+function score2(schema, value) {
+  const type = schemaType(schema, value);
+  if (type === "integer" ? !Number.isInteger(value) : type === "array" ? !Array.isArray(value) : type === "null" ? value !== null : typeof value !== type || type === "object" && (value === null || Array.isArray(value))) return -100;
+  if (own3(schema, "const")) return JSON.stringify(schema.const) === JSON.stringify(value) ? 100 : -100;
+  if (schema.enum && !schema.enum.includes(value)) return -100;
+  let result = 1;
+  const record = value;
+  for (const [key2, child] of Object.entries(schema.properties ?? {})) {
+    if (!record || !own3(record, key2)) continue;
+    if (own3(child, "const")) result += record[key2] === child.const ? 100 : -1e3;
+    else result += 1;
+  }
+  for (const key2 of schema.required ?? []) if (!record || !own3(record, key2)) result -= 2;
+  return result;
+}
+function activeSchema(schema, value, root = presentationSchema) {
+  return schemaVariants(schema, root).sort((a, b) => score2(b, value) - score2(a, value))[0] ?? {};
+}
+var INDEX = /^(?:0|[1-9][0-9]*|-)$/;
+function patternChild(schema, key2) {
+  for (const [pattern, child] of Object.entries(schema.patternProperties ?? {})) {
+    try {
+      if (new RegExp(pattern).test(key2)) return child;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function childSchema(schema, key2, value) {
+  if (Array.isArray(value) || schema.type === "array") return schema.items ?? void 0;
+  return schema.properties?.[key2] ?? patternChild(schema, key2) ?? (typeof schema.additionalProperties === "object" ? schema.additionalProperties : void 0);
+}
+function stepSchema(schema, value, key2, root) {
+  const variants = schemaVariants(schema, root).sort((a, b) => score2(b, value) - score2(a, value));
+  const first = variants[0] ?? {};
+  if (value !== void 0 || variants.length < 2 || childSchema(first, key2, value) !== void 0) return first;
+  return variants.find((variant) => variant.type === "array" ? INDEX.test(key2) && childSchema(variant, key2, value) !== void 0 : childSchema(variant, key2, value) !== void 0) ?? first;
+}
+function walk(presentation, parts2, rootSchema) {
+  let current = rootSchema;
+  let root = rootSchema;
+  let value = presentation;
+  let parent;
+  let known = true;
+  for (let index = 0; index < parts2.length; index++) {
+    const key2 = parts2[index];
+    const resolved = stepSchema(current, value, key2, root);
+    parent = resolved;
+    let next;
+    const recordSchema = parts2[0] === "catalogs" && index === 3 ? catalogSchemaNames[parts2[2]] : void 0;
+    if (recordSchema) {
+      next = schemas[recordSchema] ?? {};
+      root = next;
+    } else next = childSchema(resolved, key2, value);
+    if (next === void 0) {
+      known = false;
+      next = {};
+    }
+    current = next;
+    value = value !== null && typeof value === "object" ? value[key2] : void 0;
+  }
+  return { raw: current, schema: resolveSchema(current, root), root, parent, value, known };
+}
+function schemaAtPath(presentation, path, root = presentationSchema) {
+  return walk(presentation, splitOpfPath(path), root).schema;
+}
+function schemaLabel(schema, index = 0) {
+  const type = schemaType(schema);
+  return schema.title ?? schema.properties?.type?.const ?? (schema.const !== void 0 ? String(schema.const) : `${type}${schema.properties ? ` \xB7 ${Object.keys(schema.properties).slice(0, 3).join(", ")}` : ""}`) ?? `Option ${index + 1}`;
+}
+function createSchemaValue(schema, root = presentationSchema, depth2 = 0) {
+  if (depth2 > 20) throw new Error("Choose a shallower initial value for this recursive structure.");
+  const variants = schemaVariants(schema, root);
+  const s = variants[0] ?? {};
+  if (own3(s, "const")) return structuredClone(s.const);
+  if (own3(s, "default")) return structuredClone(s.default);
+  if (s.enum?.length) return structuredClone(s.enum[0]);
+  const type = schemaType(s);
+  if (type === "object") {
+    const value = {};
+    const properties = s.properties ?? {};
+    for (const key2 of /* @__PURE__ */ new Set([...s.required ?? [], ...Object.keys(properties).filter((name) => own3(properties[name], "const"))])) value[key2] = createSchemaValue(properties[key2] ?? {}, root, depth2 + 1);
+    return value;
+  }
+  if (type === "array") return Array.from({ length: Math.min(s.minItems ?? 0, 100) }, () => createSchemaValue(s.items ?? {}, root, depth2 + 1));
+  if (type === "boolean") return false;
+  if (type === "null") return null;
+  if (type === "number" || type === "integer") return s.minimum ?? (s.exclusiveMinimum !== void 0 ? s.exclusiveMinimum + 1 : 0);
+  if (s.examples?.length && typeof s.examples[0] === "string" && !s.examples[0].includes("...")) return s.examples[0];
+  if (s.format === "uri") return "https://example.com";
+  if (s.pattern?.includes("a-z")) return "example";
+  return s.minLength ? "Text" : "";
+}
+function listSchemaFields() {
+  const result = [];
+  for (const [name, root] of Object.entries(schemas)) {
+    const visit = (schema, path) => {
+      if (!schema || typeof schema !== "object") return;
+      for (const [key2, child] of Object.entries(schema.properties ?? {})) {
+        result.push({
+          schema: name,
+          path: formatPointer([...path, "properties", key2]),
+          name: key2,
+          description: child.description ?? "",
+          reference: child.$ref ?? null,
+          type: child.type ?? null,
+          values: child.enum ?? (own3(child, "const") ? [child.const] : null)
+        });
+        visit(child, [...path, "properties", key2]);
+      }
+      for (const [key2, child] of Object.entries(schema.$defs ?? {})) visit(child, [...path, "$defs", key2]);
+      for (const keyword of ["oneOf", "anyOf", "allOf"]) {
+        const members = schema[keyword] ?? [];
+        for (let index = 0; index < members.length; index++) visit(members[index], [...path, keyword, String(index)]);
+      }
+      if (schema.items) visit(schema.items, [...path, "items"]);
+      if (typeof schema.additionalProperties === "object") visit(schema.additionalProperties, [...path, "additionalProperties"]);
+      for (const [key2, child] of Object.entries(schema.patternProperties ?? {})) visit(child, [...path, "patternProperties", key2]);
+    };
+    visit(root, []);
+  }
+  return result;
+}
+var COMMON_KEYS = Object.freeze({
+  /** The root of a document. */
+  deck: Object.freeze(["name", "slides", "design", "language", "audience", "purpose", "tone", "narrative", "organization", "speaker"]),
+  /** A slide (`slides[n]`). */
+  slide: Object.freeze(["title", "subtitle", "layout", "items", "text", "notes", "image", "chart", "table", "quote", "code", "metric", "timeline", "blocks", "design", "id", "section", "tag", "hidden", "beat"]),
+  /** `design`, on the deck and on a slide. */
+  design: Object.freeze(["theme", "colorScheme", "fontScheme", "dimensions", "background", "header", "footer"])
+});
+var UNRANKED_PRIORITY = 1e6;
+var DEFINITION_LISTS = { Slide: COMMON_KEYS.slide, Design: COMMON_KEYS.design, SlideDesign: COMMON_KEYS.design };
+var ADVANCED_KEYS = /* @__PURE__ */ new Set(["extensions", "$schema"]);
+var REGION_KEY = /^(?:(?:top|middle|bottom)(?:\+(?:top|middle|bottom))*)?(?::)?(?:(?:left|center|right)(?:\+(?:left|center|right))*)?$/;
+function isPromotedRegionKey(key2) {
+  return key2 !== "" && key2 !== ":" && REGION_KEY.test(key2);
+}
+var uniq = (items) => [...new Set(items)];
+function variantType(variant) {
+  if (typeof variant.type === "string") return variant.type;
+  if (variant.properties || variant.additionalProperties) return "object";
+  if (variant.items) return "array";
+  if (variant.const !== void 0) return variant.const === null ? "null" : typeof variant.const;
+  if (Array.isArray(variant.enum) && variant.enum.length) return variant.enum[0] === null ? "null" : typeof variant.enum[0];
+  return "any";
+}
+var firstParagraph = (text) => typeof text === "string" && text.trim() ? (text.trim().split(/\n[ \t]*\n/)[0] ?? "").trim() : void 0;
+var definitionOf = (raw) => typeof raw.$ref === "string" ? /#\/\$defs\/([^/]+)$/.exec(raw.$ref)?.[1] : void 0;
+function enumValues(variants, inherited) {
+  const seen = /* @__PURE__ */ new Map();
+  const add = (value, description) => {
+    if (!(value === null || ["string", "number", "boolean"].includes(typeof value))) return;
+    const id = JSON.stringify(value);
+    if (!seen.has(id)) seen.set(id, { value, ...description ? { description } : {} });
+  };
+  for (const variant of variants) {
+    const own4 = typeof variant.description === "string" && variant.description !== inherited ? firstParagraph(variant.description) : void 0;
+    if (Array.isArray(variant.enum)) for (const value of variant.enum) add(value);
+    else if (variant.const !== void 0) add(variant.const, own4);
+  }
+  return [...seen.values()];
+}
+function catalogKindOf(schema, variants = []) {
+  for (const candidate of [schema, ...variants]) {
+    const kind = candidate["x-opf-catalog"];
+    if (typeof kind === "string" && own3(catalogSchemaNames, kind)) return kind;
+  }
+  return void 0;
+}
+var formRank = (variant) => {
+  if (Array.isArray(variant.enum) || variant.const !== void 0) return 0;
+  const type = variantType(variant);
+  return type === "string" || type === "boolean" || type === "number" || type === "integer" ? 0 : type === "object" ? 1 : type === "array" ? 2 : 3;
+};
+function primaryIndex(variants) {
+  let best = 0;
+  for (let index = 1; index < variants.length; index++) if (formRank(variants[index]) < formRank(variants[best])) best = index;
+  return best;
+}
+function typeLabelOf(raw, variants, root) {
+  if (variants.length > 1) return "choice";
+  const variant = variants[0] ?? {};
+  if (Array.isArray(variant.enum) && variant.enum.length > 1) return "enum";
+  const type = variantType(variant);
+  if (type === "array") {
+    const items = variant.items ?? {};
+    const name = definitionOf(items);
+    if (name) return `array of ${name}`;
+    const forms = uniq(schemaVariants(items, root).map(variantType));
+    return `array of ${forms.length === 1 ? forms[0] : forms.length ? "choice" : "any"}`;
+  }
+  if (type === "object") return definitionOf(raw) ?? "object";
+  return type;
+}
+function priorityOf(list, key2) {
+  const index = list ? list.indexOf(key2) : -1;
+  return index < 0 ? UNRANKED_PRIORITY : index;
+}
+function objectForm(variants, value) {
+  const objects = variants.filter((variant) => variantType(variant) === "object");
+  let used = objects;
+  if (objects.length > 1 && value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const best = [...objects].sort((a, b) => score2(b, value) - score2(a, value))[0];
+    if (best) used = [best];
+  }
+  const properties = /* @__PURE__ */ new Map();
+  for (const variant of used) for (const [key2, child] of Object.entries(variant.properties ?? {})) if (!properties.has(key2)) properties.set(key2, child);
+  const required = used.length ? (used[0]?.required ?? []).filter((key2) => used.every((variant) => (variant.required ?? []).includes(key2))) : [];
+  return { properties, required };
+}
+function childrenOf(form, list, isSlide, root) {
+  const children = [];
+  for (const [key2, raw] of form.properties) {
+    const resolved = resolveSchema(raw, root);
+    const variants = schemaVariants(raw, root);
+    const description = firstParagraph(resolved.description);
+    const catalogKind = catalogKindOf(resolved, variants);
+    children.push({
+      key: key2,
+      types: uniq(variants.map(variantType)),
+      typeLabel: typeLabelOf(raw, variants, root),
+      required: form.required.includes(key2),
+      advanced: ADVANCED_KEYS.has(key2) || isSlide && isPromotedRegionKey(key2),
+      priority: priorityOf(list, key2),
+      ...description ? { description } : {},
+      ...catalogKind ? { catalogKind } : {},
+      ...resolved.deprecated === true ? { deprecated: true } : {},
+      hasEnum: variants.some((variant) => Array.isArray(variant.enum) || variant.const !== void 0)
+    });
+  }
+  return children.sort(
+    (a, b) => Number(b.required) - Number(a.required) || Number(a.advanced) - Number(b.advanced) || a.priority - b.priority || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
+  );
+}
+function nodeSegments(path) {
+  const parts2 = splitOpfPath(path);
+  const shown = Array.isArray(path) ? [...path] : parts2.map((part) => /^(?:0|[1-9][0-9]*)$/.test(part) ? Number(part) : part);
+  return { parts: parts2, shown };
+}
+var MAX_ITEM_DEPTH = 3;
+function describeAt(presentation, path, depth2) {
+  let parts2;
+  let shown;
+  try {
+    ({ parts: parts2, shown } = nodeSegments(path));
+  } catch {
+    return unknownField(Array.isArray(path) ? [...path] : [], "");
+  }
+  const pointer4 = formatPointer(parts2);
+  const found = walk(presentation, parts2, presentationSchema);
+  if (!found.known) return unknownField(shown, pointer4);
+  const { raw, schema, root, parent, value } = found;
+  const variants = schemaVariants(raw, root);
+  const inherited = schema.description;
+  const last = parts2.at(-1);
+  const parentIsArray = parent !== void 0 && variantType(parent) === "array";
+  const key2 = last !== void 0 && !parentIsArray ? last : void 0;
+  const definition = definitionOf(raw);
+  const description = firstParagraph(schema.description);
+  const enumList = enumValues(variants, inherited);
+  const primary = primaryIndex(variants);
+  const catalogKind = catalogKindOf(schema, variants);
+  const form = objectForm(variants, value);
+  const isRoot = parts2.length === 0;
+  const list = isRoot ? COMMON_KEYS.deck : definition ? DEFINITION_LISTS[definition] : void 0;
+  const infos2 = variants.map((variant) => {
+    const type = variantType(variant);
+    const items = type === "array" ? variant.items ?? {} : void 0;
+    const variantEnum = enumValues([variant], inherited);
+    return {
+      type,
+      ...typeof variant.title === "string" ? { title: variant.title } : {},
+      ...variantEnum.length ? { enum: variantEnum } : {},
+      ...variant.const !== void 0 ? { const: variant.const } : {},
+      requiredChildren: [...variant.required ?? []],
+      properties: Object.keys(variant.properties ?? {}),
+      ...items ? { itemsType: uniq(schemaVariants(items, root).map(variantType)).join(" | ") || "any" } : {},
+      ...items && definitionOf(items) ? { itemsDefinition: definitionOf(items) } : {}
+    };
+  });
+  const primaryVariant = variants[primary] ?? {};
+  const freeText = variantType(primaryVariant) === "string" && primaryVariant.enum === void 0 && primaryVariant.const === void 0 && primaryVariant.pattern === void 0 && primaryVariant.format === void 0 && catalogKind === void 0;
+  const info = {
+    known: true,
+    path: shown,
+    pointer: pointer4,
+    ...key2 !== void 0 ? { key: key2 } : {},
+    types: uniq(infos2.map((variant) => variant.type)),
+    ...description ? { description } : {},
+    ...typeof schema.description === "string" && schema.description.trim() ? { fullDescription: schema.description.trim() } : {},
+    ...definition ? { definition } : {},
+    required: key2 !== void 0 && Array.isArray(parent?.required) && parent.required.includes(key2),
+    ...schema.deprecated === true ? { deprecated: true } : {},
+    examples: Array.isArray(schema.examples) ? [...schema.examples] : [],
+    ...own3(schema, "default") ? { default: schema.default } : {},
+    ...enumList.length ? { enum: enumList } : {},
+    ...catalogKind ? { catalogKind } : {},
+    variants: infos2,
+    primary,
+    children: childrenOf(form, list, definition === "Slide", root),
+    requiredChildren: form.required,
+    freeText
+  };
+  const arrayVariant = variants.find((variant) => variantType(variant) === "array") ?? void 0;
+  if (arrayVariant && depth2 < MAX_ITEM_DEPTH) {
+    const next = Array.isArray(value) ? value.length : 0;
+    info.itemInfo = describeAt(presentation, [...parts2, String(next)], depth2 + 1);
+    info.itemInfo.path = [...shown, next];
+  }
+  const mapVariant = variants.find((variant) => variantType(variant) === "object" && typeof variant.additionalProperties === "object");
+  if (mapVariant && depth2 < MAX_ITEM_DEPTH) info.entryInfo = describeAt(presentation, [...parts2, "*"], depth2 + 1);
+  if (info.entryInfo) info.entryInfo.path = [...shown, "*"];
+  return info;
+}
+function unknownField(path, pointer4) {
+  return { known: false, path, pointer: pointer4, types: [], required: false, examples: [], variants: [], primary: 0, children: [], requiredChildren: [], freeText: false };
+}
+function describeField(path, document) {
+  return describeAt(document, path, 0);
+}
+function catalogKindAt(path, document) {
+  let parts2;
+  try {
+    parts2 = splitOpfPath(path);
+  } catch {
+    return void 0;
+  }
+  const found = walk(document, parts2, presentationSchema);
+  return found.known ? catalogKindOf(found.schema, schemaVariants(found.raw, found.root)) : void 0;
+}
+
+// src/source-text.ts
+function createLocator(text) {
+  const lineStarts = [0];
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code === 13) {
+      if (text.charCodeAt(index + 1) === 10) index++;
+      lineStarts.push(index + 1);
+    } else if (code === 10) lineStarts.push(index + 1);
+  }
+  return (offset, length) => {
+    let low = 0;
+    let high = lineStarts.length;
+    while (low + 1 < high) {
+      const middle = low + high >> 1;
+      if ((lineStarts[middle] ?? 0) <= offset) low = middle;
+      else high = middle;
+    }
+    return { offset, length, line: low + 1, column: offset - (lineStarts[low] ?? 0) + 1 };
+  };
+}
+function applyTextEdits(text, edits) {
+  const ordered = edits.map((edit, index) => ({ edit, index })).sort((a, b) => a.edit.offset - b.edit.offset || a.index - b.index);
+  let result = "";
+  let cursor = 0;
+  for (const { edit } of ordered) {
+    if (edit.offset < cursor) throw new RangeError("Text edits overlap.");
+    result += text.slice(cursor, edit.offset) + edit.insert;
+    cursor = edit.offset + edit.length;
+  }
+  return result + text.slice(cursor);
+}
+
+// src/json-syntax.ts
+var WORD = /[\p{L}\p{N}_$.+\-%]/u;
+var NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
+var TYPOGRAPHIC = /[\u2018-\u201F\u00AB\u00BB]/;
+var HEX = /^[0-9a-fA-F]{4}$/;
+var isBreak = (char) => char === "\n" || char === "\r";
+function tokenize(text) {
+  const tokens = [];
+  const lexical = { escapes: /* @__PURE__ */ new Map(), unicode: /* @__PURE__ */ new Map(), controls: /* @__PURE__ */ new Map() };
+  const length = text.length;
+  let index = text.charCodeAt(0) === 65279 ? 1 : 0;
+  const push = (token) => {
+    const full = { ...token, text: text.slice(token.start, token.end) };
+    tokens.push(full);
+    return full;
+  };
+  while (index < length) {
+    const char = text[index];
+    if (char === " " || char === "	" || char === "\n" || char === "\r") {
+      index++;
+      continue;
+    }
+    const start = index;
+    if (char === "{" || char === "}" || char === "[" || char === "]" || char === "," || char === ":") {
+      index++;
+      push({ kind: char === "{" ? "lbrace" : char === "}" ? "rbrace" : char === "[" ? "lbracket" : char === "]" ? "rbracket" : char === "," ? "comma" : "colon", start, end: index });
+      continue;
+    }
+    if (char === '"') {
+      index++;
+      const escapes = [];
+      const unicode = [];
+      const controls = [];
+      let terminated = false;
+      while (index < length) {
+        const current = text[index];
+        if (current === '"') {
+          terminated = true;
+          index++;
+          break;
+        }
+        if (isBreak(current)) break;
+        if (current === "\\") {
+          const following = text[index + 1];
+          if (following === void 0 || isBreak(following)) {
+            escapes.push(index);
+            index++;
+          } else if (following === "u") {
+            if (HEX.test(text.slice(index + 2, index + 6))) index += 6;
+            else {
+              unicode.push(index);
+              index += 2;
+            }
+          } else if ('"\\/bfnrt'.includes(following)) index += 2;
+          else {
+            escapes.push(index);
+            index += 1 + ((following.codePointAt(0) ?? 0) > 65535 ? 2 : 1);
+          }
+          continue;
+        }
+        if (current < " ") controls.push(index);
+        index++;
+      }
+      const token = push({ kind: "string", start, end: index, quote: "double", terminated });
+      if (escapes.length) lexical.escapes.set(token, escapes);
+      if (unicode.length) lexical.unicode.set(token, unicode);
+      if (controls.length) lexical.controls.set(token, controls);
+      continue;
+    }
+    if (char === "'") {
+      index++;
+      let terminated = false;
+      while (index < length) {
+        const current = text[index];
+        if (isBreak(current)) break;
+        if (current === "\\" && index + 1 < length && !isBreak(text[index + 1])) {
+          index += 2;
+          continue;
+        }
+        index++;
+        if (current === "'") {
+          terminated = true;
+          break;
+        }
+      }
+      push({ kind: "string", start, end: index, quote: "single", terminated });
+      continue;
+    }
+    if (TYPOGRAPHIC.test(char)) {
+      index++;
+      let terminated = false;
+      while (index < length) {
+        const current = text[index];
+        if (isBreak(current)) break;
+        index++;
+        if (current === '"' || TYPOGRAPHIC.test(current)) {
+          terminated = true;
+          break;
+        }
+      }
+      push({ kind: "string", start, end: index, quote: "typographic", terminated });
+      continue;
+    }
+    if (char === "/" && text[index + 1] === "/") {
+      while (index < length && !isBreak(text[index])) index++;
+      push({ kind: "comment", start, end: index });
+      continue;
+    }
+    if (char === "/" && text[index + 1] === "*") {
+      const close = text.indexOf("*/", index + 2);
+      index = close < 0 ? length : close + 2;
+      push({ kind: "comment", start, end: index, block: true, terminated: close >= 0 });
+      continue;
+    }
+    if (WORD.test(String.fromCodePoint(text.codePointAt(index) ?? 0))) {
+      while (index < length) {
+        const code = text.codePointAt(index) ?? 0;
+        if (!WORD.test(String.fromCodePoint(code))) break;
+        index += code > 65535 ? 2 : 1;
+      }
+      const lexeme = text.slice(start, index);
+      const kind = NUMBER.test(lexeme) ? "number" : lexeme === "true" || lexeme === "false" || lexeme === "null" ? "literal" : /^[+\-.]?[0-9]|^[+-]$/.test(lexeme) ? "badnumber" : "word";
+      push({ kind, start, end: index });
+      continue;
+    }
+    while (index < length) {
+      const code = text.codePointAt(index) ?? 0;
+      const next = String.fromCodePoint(code);
+      if (/[\s{}[\],:"'/]/.test(next) || TYPOGRAPHIC.test(next) || WORD.test(next)) break;
+      index += code > 65535 ? 2 : 1;
+    }
+    if (index === start) index += (text.codePointAt(index) ?? 0) > 65535 ? 2 : 1;
+    push({ kind: "unknown", start, end: index });
+  }
+  push({ kind: "eof", start: length, end: length });
+  return { tokens, lexical };
+}
+var KIND_NAMES = { layouts: "layout", themes: "theme", colorSchemes: "color scheme", fontSchemes: "font scheme", narratives: "narrative", audiences: "audience", purposes: "purpose", tones: "tone" };
+function clip(value, max = 40) {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max - 1)}\u2026` : collapsed;
+}
+function lineBounds(text, offset) {
+  let start = offset;
+  while (start > 0 && !isBreak(text[start - 1])) start--;
+  let end = offset;
+  while (end < text.length && !isBreak(text[end])) end++;
+  return { start, end };
+}
+var indentOf = (text, offset) => /^[ \t]*/.exec(text.slice(lineBounds(text, offset).start))?.[0] ?? "";
+function unquoteSingle(raw) {
+  const inner = raw.endsWith("'") && raw.length > 1 ? raw.slice(1, -1) : raw.slice(1);
+  let result = "";
+  for (let index = 0; index < inner.length; index++) {
+    const char = inner[index];
+    if (char === "\\" && inner[index + 1] === "'") {
+      result += "'";
+      index++;
+    } else if (char === "\\" && index + 1 < inner.length) {
+      result += char + inner[index + 1];
+      index++;
+    } else if (char === '"') result += '\\"';
+    else result += char;
+  }
+  return `"${result}"`;
+}
 var YAML_START = /^[A-Za-z_][\w.-]*\s*:(?:\s|$)/;
-function hint(source) {
-  const text = source.replace(/^\uFEFF/, "").trimStart();
-  if (text.startsWith("{") || text.startsWith("[") || text === "") return "";
-  if (text.startsWith("---") || !text.startsWith("#") && YAML_START.test(text))
-    return " This looks like YAML: read it with fromYaml, then validate the presentation it returns.";
-  if (text.startsWith("#")) return " This looks like Markdown: read it with fromMarkdown, then validate the presentation it returns.";
-  return "";
+var MINIMAL_DECK = '{\n  "slides": [\n    { "title": "" }\n  ]\n}\n';
+var HINT_FORMS_LIMIT = 2;
+var Analyzer = class {
+  constructor(text) {
+    this.text = text;
+    const lexed = tokenize(text);
+    this.comments = lexed.tokens.filter((token) => token.kind === "comment");
+    this.tokens = lexed.tokens.filter((token) => token.kind !== "comment");
+    this.lexical = lexed.lexical;
+    this.locate = createLocator(text);
+  }
+  text;
+  problems = [];
+  tokens;
+  comments;
+  lexical;
+  locate;
+  index = 0;
+  muteIndex = -1;
+  last;
+  stack = [];
+  order = 0;
+  // Containers left open at the same place close together: the outer one's fix inserts the inner ones' closers first.
+  cascade = { last: void 0, inserts: [] };
+  // -- reporting --
+  add(problem) {
+    this.problems.push({ problem: { severity: "error", ...problem }, order: this.order++ });
+  }
+  /** A structural problem about the token at the read position: dropped when it is the aftershock of the cause just reported. */
+  structural(problem) {
+    if (this.index <= this.muteIndex) return;
+    this.add(problem);
+  }
+  mute() {
+    this.muteIndex = this.index;
+  }
+  range(start, end) {
+    return this.locate(start, Math.max(0, end - start));
+  }
+  line(offset) {
+    return this.locate(offset, 0).line;
+  }
+  // -- tokens --
+  peek(ahead = 0) {
+    return this.tokens[Math.min(this.index + ahead, this.tokens.length - 1)];
+  }
+  take() {
+    const token = this.peek();
+    if (token.kind !== "eof") {
+      this.index++;
+      this.last = token;
+    }
+    return token;
+  }
+  startsEntry(offset = 0) {
+    const token = this.peek(offset);
+    return token.kind === "string" || token.kind === "word" && this.peek(offset + 1).kind === "colon";
+  }
+  // -- the document --
+  run() {
+    const first = this.peek();
+    if (first.kind !== "eof" && first.kind !== "lbrace" && first.kind !== "lbracket" && this.looksLikeOtherFormat(first)) return;
+    this.lexicalProblems();
+    if (first.kind === "eof") {
+      this.emptyDocument();
+      return;
+    }
+    if (first.kind === "word" || first.kind === "unknown" || first.kind === "colon" || first.kind === "comma" || first.kind === "rbrace" || first.kind === "rbracket") {
+      this.add({
+        code: "invalid-symbol",
+        range: this.range(first.start, first.end),
+        message: `Unexpected ${first.kind === "word" || first.kind === "unknown" ? `\`${clip(first.text, 24)}\`` : `\`${first.text}\``} at the start of the document.`,
+        next: 'start with { for a deck, for example { "slides": [ { "title": "\u2026" } ] }.',
+        fixes: []
+      });
+      return;
+    }
+    const root = this.parseValue([], void 0);
+    if (root) {
+      if (root.kind !== "object") this.notAnObject(root, first);
+      const extra = this.peek();
+      if (extra.kind !== "eof") {
+        const end = this.text.trimEnd().length;
+        const closer = root.kind === "object" ? "}" : root.kind === "array" ? "]" : "value";
+        this.add({
+          code: "content-after-root",
+          range: this.range(extra.start, Math.max(end, extra.end)),
+          message: `Unexpected content after the closing ${closer === "value" ? "value" : `\`${closer}\``} on line ${this.line(Math.max(root.end - 1, 0))}. A JSON file holds one value.`,
+          next: "remove the extra text, or put it inside the object.",
+          fixes: [{ id: "remove-extra", title: "Remove the extra text", safe: false, edits: [{ offset: root.end, length: Math.max(end, extra.end) - root.end, insert: "" }] }]
+        });
+      }
+    }
+  }
+  emptyDocument() {
+    const length = this.text.length;
+    this.add({
+      code: "empty-document",
+      range: this.range(0, length),
+      message: "The document is empty.",
+      next: 'start with { "slides": [ { "title": "\u2026" } ] }.',
+      fixes: [{ id: "insert-minimal-deck", title: "Insert minimal deck", safe: false, edits: [{ offset: 0, length, insert: MINIMAL_DECK }], caret: MINIMAL_DECK.indexOf('""') + 1 }]
+    });
+  }
+  looksLikeOtherFormat(first) {
+    const head = this.text.slice(first.start);
+    const lineEnd = lineBounds(this.text, first.start).end;
+    const range = this.range(first.start, Math.max(first.end, this.text.slice(0, lineEnd).trimEnd().length));
+    if (/^---(?:\s|$)/.test(head) || !head.startsWith("#") && YAML_START.test(head) || /^-\s+\S/.test(head)) {
+      this.add({
+        code: "looks-like-yaml",
+        range,
+        message: "This is not JSON. It looks like YAML.",
+        next: "switch the format to YAML (read it with fromYaml, then validate the presentation it returns), or add braces and quotes to make it JSON.",
+        fixes: [{ id: "switch-yaml", title: "Switch format to YAML", safe: false, edits: [], action: "switch-format", format: "yaml" }]
+      });
+      return true;
+    }
+    if (head.startsWith("#") || head.startsWith("```") || /^>\s/.test(head) || /^[*]\s+\S/.test(head)) {
+      this.add({
+        code: "looks-like-markdown",
+        range,
+        message: "This is not JSON. It looks like Markdown.",
+        next: "switch the format to Markdown (read it with fromMarkdown, then validate the presentation it returns), or write the deck as a JSON object.",
+        fixes: [{ id: "switch-markdown", title: "Switch format to Markdown", safe: false, edits: [], action: "switch-format", format: "md" }]
+      });
+      return true;
+    }
+    return false;
+  }
+  notAnObject(root, first) {
+    const literal = this.text.slice(root.start, root.end);
+    const what = root.kind === "array" ? "an array" : root.kind === "string" ? "a string" : literal === "true" || literal === "false" ? "a boolean" : literal === "null" ? "null" : "a number";
+    const wrap = root.kind === "array" ? [
+      {
+        id: "wrap-slides",
+        title: 'Wrap in { "slides" ... }',
+        safe: false,
+        edits: [
+          { offset: root.start, length: 0, insert: '{ "slides": ' },
+          { offset: root.end, length: 0, insert: " }" }
+        ]
+      }
+    ] : [];
+    this.add({
+      code: "not-an-object",
+      range: this.range(first.start, root.kind === "array" ? first.end : root.end),
+      message: `The top level must be an object { \u2026 }, but this is ${what}.`,
+      next: root.kind === "array" ? 'wrap it as { "slides": [ \u2026 ] }.' : 'write an object such as { "slides": [ { "title": "\u2026" } ] }.',
+      fixes: wrap
+    });
+  }
+  // -- lexical problems (no structure needed) --
+  lexicalProblems() {
+    for (const token of this.comments) {
+      const unclosed = token.block && token.terminated === false;
+      const whole = this.removalOf(token);
+      if (unclosed) {
+        this.add({
+          code: "unclosed-comment",
+          range: this.range(token.start, token.start + 2),
+          message: "This `/*` comment is never closed.",
+          next: "end it with `*/`, or remove it. Everything after `/*` is part of the comment.",
+          fixes: [
+            { id: "close-comment", title: "Close comment", safe: false, edits: [{ offset: this.text.length, length: 0, insert: " */" }] },
+            { id: "remove-comment", title: "Remove comment", safe: false, edits: [whole] }
+          ]
+        });
+      } else {
+        this.add({
+          code: "comment",
+          range: this.range(token.start, token.end),
+          message: "JSON does not allow comments.",
+          next: "remove it, or switch to YAML, where # comments are kept.",
+          fixes: [
+            { id: "remove-comment", title: "Remove comment", safe: true, edits: [whole] },
+            { id: "switch-yaml", title: "Switch format to YAML", safe: false, edits: [], action: "switch-format", format: "yaml" }
+          ]
+        });
+      }
+    }
+    for (const token of this.tokens) {
+      if (token.kind === "string") this.stringProblems(token);
+      else if (token.kind === "badnumber") this.numberProblem(token);
+      else if (token.kind === "unknown") this.unknownProblem(token);
+    }
+  }
+  /** The edit that removes a comment: its whole line when it stands alone on it, else just the comment and the spaces before it. */
+  removalOf(token) {
+    let start = token.start;
+    let end = token.end;
+    while (start > 0 && (this.text[start - 1] === " " || this.text[start - 1] === "	")) start--;
+    const alone = start === 0 || isBreak(this.text[start - 1]);
+    let after = end;
+    while (after < this.text.length && (this.text[after] === " " || this.text[after] === "	")) after++;
+    if (alone && (after >= this.text.length || isBreak(this.text[after]))) {
+      end = after;
+      if (this.text[end] === "\r" && this.text[end + 1] === "\n") end += 2;
+      else if (end < this.text.length) end++;
+      return { offset: start, length: end - start, insert: "" };
+    }
+    return { offset: start, length: end - start, insert: "" };
+  }
+  stringProblems(token) {
+    const { text } = this;
+    if (token.quote === "single") {
+      this.add({
+        code: "single-quotes",
+        range: this.range(token.start, token.end),
+        message: "JSON strings use double quotes, not single quotes.",
+        next: `write ${unquoteSingle(token.text)} instead of ${clip(token.text, 30)}.`,
+        fixes: [{ id: "double-quotes", title: "Use double quotes", safe: true, edits: [{ offset: token.start, length: token.end - token.start, insert: unquoteSingle(token.text) }] }]
+      });
+      return;
+    }
+    if (token.quote === "typographic") {
+      const edits = [{ offset: token.start, length: 1, insert: '"' }];
+      if (token.terminated) edits.push({ offset: token.end - 1, length: 1, insert: '"' });
+      this.add({
+        code: "typographic-quotes",
+        range: this.range(token.start, token.end),
+        message: 'These are typographic quotes; JSON needs straight quotes (").',
+        next: "replace them with straight double quotes. Word processors and chat apps change them as you paste.",
+        fixes: [{ id: "straight-quotes", title: "Replace with straight quotes", safe: token.terminated === true, edits }]
+      });
+      return;
+    }
+    const escapes = this.lexical.escapes.get(token);
+    const unicode = this.lexical.unicode.get(token);
+    const controls = this.lexical.controls.get(token);
+    if (token.terminated === false) {
+      const lineEnd = token.start + clipTrailing(text.slice(token.start, token.end)).length;
+      this.add({
+        code: "unclosed-string",
+        range: this.range(token.start, lineEnd),
+        message: "This string is not closed before the end of the line.",
+        next: "close it with a double quote. JSON strings stay on one line: write a line break as \\n.",
+        fixes: [{ id: "close-string", title: "Close the string", safe: false, edits: [{ offset: lineEnd, length: 0, insert: '"' }] }]
+      });
+    }
+    if (escapes?.length) {
+      const first = escapes[0];
+      const shown = text.slice(first, first + 2);
+      this.add({
+        code: "invalid-escape",
+        range: this.range(first, Math.min(token.end, first + 2)),
+        message: `\`${shown.trim() || "\\"}\` is not a JSON escape.`,
+        next: 'write a backslash as \\\\ (the valid escapes are \\" \\\\ \\/ \\b \\f \\n \\r \\t and \\uXXXX).',
+        fixes: [{ id: "double-backslash", title: escapes.length > 1 ? "Double the backslashes" : "Double the backslash", safe: false, edits: escapes.map((offset) => ({ offset, length: 0, insert: "\\" })) }]
+      });
+    }
+    if (unicode?.length) {
+      const first = unicode[0];
+      this.add({
+        code: "invalid-unicode",
+        range: this.range(first, Math.min(token.end, first + 6)),
+        message: "`\\u` must be followed by four hex digits.",
+        next: "write the character as \\u00e9 (four digits 0 to 9 and a to f), or as the character itself.",
+        fixes: []
+      });
+    }
+    if (controls?.length) {
+      const first = controls[0];
+      this.add({
+        code: "control-character",
+        range: this.range(first, first + 1),
+        message: "A tab or control character sits inside this string.",
+        next: "write it as \\t, or as \\n for a line break.",
+        fixes: [
+          {
+            id: "escape-controls",
+            title: "Replace with escape",
+            safe: true,
+            edits: controls.map((offset) => {
+              const code = text.charCodeAt(offset);
+              const named = { 8: "\\b", 9: "\\t", 12: "\\f" };
+              return { offset, length: 1, insert: named[code] ?? `\\u${code.toString(16).padStart(4, "0")}` };
+            })
+          }
+        ]
+      });
+    }
+  }
+  numberProblem(token) {
+    const word = token.text;
+    const fixes = [];
+    let message = `\`${word}\` is not a JSON number.`;
+    let next = "Numbers have no leading zero, plus sign or trailing dot; put text such as 12% in quotes.";
+    const numeric = (id, title, value) => {
+      fixes.push({ id, title, safe: false, edits: [{ offset: token.start, length: token.end - token.start, insert: value }] });
+    };
+    if (/^0[0-9]+$/.test(word) || /^-0[0-9]+$/.test(word)) {
+      message = `\`${word}\` has a leading zero, which JSON numbers do not allow.`;
+      next = 'remove the leading zero, or put it in quotes if it is an identifier such as "007".';
+      numeric("remove-leading-zero", "Remove leading zeros", word.replace(/^(-?)0+(?=[0-9])/, "$1"));
+    } else if (/^\+[0-9]/.test(word) && NUMBER.test(word.slice(1))) {
+      message = `\`${word}\` has a plus sign, which JSON numbers do not allow.`;
+      next = "remove the plus sign.";
+      numeric("remove-plus", "Remove plus sign", word.slice(1));
+    } else if (/^-?\.[0-9]+(?:[eE][+-]?[0-9]+)?$/.test(word)) {
+      message = `\`${word}\` is missing the digit before the dot.`;
+      next = `write ${word.startsWith("-") ? "-0" : "0"}${word.replace("-", "")}.`;
+      numeric("add-leading-zero", "Add leading zero", `${word.startsWith("-") ? "-0" : "0"}${word.replace("-", "")}`);
+    } else if (/^-?[0-9]+\.(?:[eE][+-]?[0-9]+)?$/.test(word)) {
+      message = `\`${word}\` ends with a dot, which JSON numbers do not allow.`;
+      next = "remove the dot or add digits after it.";
+      numeric("remove-trailing-dot", "Remove trailing dot", word.replace(".", ""));
+    }
+    fixes.push({ id: "quote-value", title: "Quote the value", safe: false, edits: [{ offset: token.start, length: token.end - token.start, insert: JSON.stringify(word) }] });
+    this.add({ code: "invalid-number", range: this.range(token.start, token.end), message, next, fixes });
+  }
+  unknownProblem(token) {
+    if (token === this.tokens[0]) return;
+    const shown = clip(token.text, 12);
+    const invisible = /^[\s\u200B-\u200D\u2060\uFEFF]+$/u.test(token.text);
+    this.add({
+      code: "invalid-symbol",
+      range: this.range(token.start, token.end),
+      message: invisible ? "An invisible or non-standard space sits here." : `Unexpected character \`${shown}\`.`,
+      next: invisible ? "remove it, or replace it with a regular space. JSON allows only space, tab and line breaks between tokens." : "remove it. JSON has no use for this character outside a string.",
+      fixes: [{ id: "remove-character", title: invisible ? "Replace with a space" : "Remove the character", safe: invisible, edits: [{ offset: token.start, length: token.end - token.start, insert: invisible ? " " : "" }] }]
+    });
+  }
+  // -- values --
+  parseValue(path, key2) {
+    const token = this.peek();
+    switch (token.kind) {
+      case "lbrace":
+        return this.parseObject(path);
+      case "lbracket":
+        return this.parseArray(path);
+      case "string": {
+        this.take();
+        if (token.terminated === false) this.mute();
+        return { start: token.start, end: token.end, kind: "string" };
+      }
+      case "number":
+      case "literal":
+      case "badnumber":
+        this.take();
+        return { start: token.start, end: token.end, kind: "scalar" };
+      case "word":
+        this.take();
+        this.bareWord(token, path, key2);
+        return { start: token.start, end: token.end, kind: "scalar" };
+      case "unknown":
+        this.take();
+        return { start: token.start, end: token.end, kind: "scalar" };
+      default:
+        return void 0;
+    }
+  }
+  bareWord(token, path, key2) {
+    const word = token.text;
+    const lower = word.toLowerCase();
+    const edit = (insert) => [{ offset: token.start, length: token.end - token.start, insert }];
+    let message;
+    let next;
+    const fixes = [];
+    if (lower === "true" || lower === "false") {
+      message = `\`${word}\` is not JSON. Write ${lower} in lowercase.`;
+      next = `write ${lower}, or "${word}" in quotes if it is text.`;
+      fixes.push({ id: `use-${lower}`, title: `Use ${lower}`, safe: true, edits: edit(lower) });
+    } else if (["none", "nil", "null", "undefined", "nan", "infinity", "-infinity", "+infinity", "inf"].includes(lower)) {
+      message = lower === "null" ? "`" + word + "` is not JSON. Write null in lowercase." : `\`${word}\` is not JSON. Use null for no value.`;
+      next = "write null, or put it in quotes if it is text. JSON has no NaN, Infinity or undefined.";
+      fixes.push({ id: "use-null", title: "Use null", safe: lower === "null", edits: edit("null") });
+    } else {
+      message = key2 !== void 0 ? `\`${key2}\` needs a quoted string: ${JSON.stringify(word)}.` : `\`${clip(word, 24)}\` needs quotes to be text: ${JSON.stringify(word)}.`;
+      next = `put it in double quotes: ${JSON.stringify(word)}.`;
+    }
+    fixes.push({ id: "quote-value", title: "Quote the value", safe: false, edits: edit(JSON.stringify(word)) });
+    this.add({ code: "bare-word", range: this.range(token.start, token.end), message, next, path: [...path], fixes });
+  }
+  parseObject(path) {
+    const open = this.take();
+    const container = { type: "{", open, path };
+    this.stack.push(container);
+    let expectKey = true;
+    let comma;
+    let lastEntry;
+    let valueEnd = open.end;
+    for (; ; ) {
+      const token = this.peek();
+      if (token.kind === "rbrace") {
+        if (comma && expectKey) this.trailingComma(comma, container, lastEntry);
+        this.take();
+        this.stack.pop();
+        return { start: open.start, end: token.end, kind: "object" };
+      }
+      if (token.kind === "eof") {
+        this.unclosed(container);
+        this.stack.pop();
+        return { start: open.start, end: this.last?.end ?? open.end, kind: "object" };
+      }
+      if (token.kind === "rbracket") {
+        if (this.closeMismatched(container, token)) return { start: open.start, end: token.end, kind: "object" };
+        this.unclosed(container);
+        this.stack.pop();
+        return { start: open.start, end: this.last?.end ?? open.end, kind: "object" };
+      }
+      if (token.kind === "comma") {
+        if (expectKey) this.doubleComma(token, container, comma !== void 0 || lastEntry !== void 0);
+        else comma = token;
+        this.take();
+        expectKey = true;
+        continue;
+      }
+      if (!expectKey) {
+        if (this.startsEntry()) {
+          this.structural({
+            code: "missing-comma",
+            range: this.range(valueEnd - 1, valueEnd),
+            path: [...path],
+            ...this.missingComma(valueEnd, lastEntry)
+          });
+        } else if (token.kind === "lbrace" || token.kind === "lbracket") {
+          this.unclosed(container);
+          this.stack.pop();
+          return { start: open.start, end: this.last?.end ?? open.end, kind: "object" };
+        } else {
+          this.take();
+          this.unexpected(token, "a comma or }");
+          valueEnd = token.end;
+          continue;
+        }
+      }
+      const entryStart = token.start;
+      if (token.kind === "string" || token.kind === "word" && this.peek(1).kind === "colon") {
+        const keyToken = this.take();
+        if (token.kind === "word") this.unquotedKey(keyToken, path);
+        if (keyToken.terminated === false) this.mute();
+        const entryKey = keyToken.kind === "string" ? keyName(keyToken) : keyToken.text;
+        const entryPath = [...path, entryKey];
+        let hasColon = false;
+        let colon;
+        if (this.peek().kind === "colon") {
+          colon = this.take();
+          hasColon = true;
+        } else {
+          const following = this.peek();
+          const valueFollows = following.kind === "lbrace" || following.kind === "lbracket" || following.kind === "number" || following.kind === "literal" || following.kind === "badnumber" || following.kind === "unknown" || (following.kind === "string" || following.kind === "word") && this.peek(1).kind !== "colon";
+          this.missingColon(keyToken, entryKey, entryPath, valueFollows, container);
+          if (!valueFollows) {
+            this.mute();
+            expectKey = false;
+            comma = void 0;
+            valueEnd = keyToken.end;
+            lastEntry = { start: entryStart, text: clip(this.text.slice(entryStart, keyToken.end)) };
+            continue;
+          }
+        }
+        let value;
+        const after = this.peek();
+        const keyIsNext = (after.kind === "string" || after.kind === "word") && this.peek(1).kind === "colon";
+        if (hasColon && (after.kind === "rbrace" || after.kind === "rbracket" || after.kind === "comma" || after.kind === "eof" || keyIsNext)) {
+          this.missingValue(keyToken, colon, entryKey, entryPath);
+          this.mute();
+          valueEnd = colon.end;
+        } else {
+          value = this.parseValue(entryPath, entryKey);
+          valueEnd = value?.end ?? keyToken.end;
+        }
+        const entryEnd = value?.end ?? valueEnd;
+        lastEntry = { start: entryStart, text: entryText(this.text, entryStart, entryEnd, value?.kind) };
+        expectKey = false;
+        comma = void 0;
+        continue;
+      }
+      if (token.kind === "lbrace" || token.kind === "lbracket") {
+        this.unexpected(token, "a property name");
+        valueEnd = this.parseValue([...path], void 0)?.end ?? valueEnd;
+        this.mute();
+      } else {
+        this.take();
+        this.unexpected(token, "a property name (a quoted string)");
+        this.mute();
+        valueEnd = token.end;
+      }
+      expectKey = false;
+      comma = void 0;
+    }
+  }
+  parseArray(path) {
+    const open = this.take();
+    const container = { type: "[", open, path };
+    this.stack.push(container);
+    let expectItem = true;
+    let comma;
+    let count = 0;
+    let valueEnd = open.end;
+    let lastItem;
+    for (; ; ) {
+      const token = this.peek();
+      if (token.kind === "rbracket") {
+        if (comma && expectItem) this.trailingComma(comma, container, lastItem);
+        this.take();
+        this.stack.pop();
+        return { start: open.start, end: token.end, kind: "array" };
+      }
+      if (token.kind === "eof") {
+        this.unclosed(container);
+        this.stack.pop();
+        return { start: open.start, end: this.last?.end ?? open.end, kind: "array" };
+      }
+      if (token.kind === "rbrace") {
+        if (this.closeMismatched(container, token)) return { start: open.start, end: token.end, kind: "array" };
+        this.unclosed(container);
+        this.stack.pop();
+        return { start: open.start, end: this.last?.end ?? open.end, kind: "array" };
+      }
+      if (token.kind === "comma") {
+        if (expectItem) this.doubleComma(token, container, comma !== void 0 || lastItem !== void 0);
+        else comma = token;
+        this.take();
+        expectItem = true;
+        continue;
+      }
+      const startsValue = token.kind === "string" || token.kind === "number" || token.kind === "literal" || token.kind === "badnumber" || token.kind === "word" || token.kind === "lbrace" || token.kind === "lbracket";
+      if (!startsValue) {
+        this.take();
+        this.unexpected(token, "a value");
+        this.mute();
+        valueEnd = token.end;
+        continue;
+      }
+      if (!expectItem) {
+        this.structural({
+          code: "missing-comma",
+          range: this.range(valueEnd - 1, valueEnd),
+          path: [...path],
+          ...this.missingComma(valueEnd, lastItem)
+        });
+      }
+      const itemStart = token.start;
+      const value = this.parseValue([...path, count], void 0);
+      count++;
+      valueEnd = value?.end ?? token.end;
+      lastItem = { start: itemStart, text: entryText(this.text, itemStart, valueEnd, value?.kind) };
+      expectItem = false;
+      comma = void 0;
+    }
+  }
+  // -- structural problems --
+  missingComma(valueEnd, previous) {
+    const line = this.line(Math.max(valueEnd - 1, 0));
+    return {
+      message: `Missing comma after ${previous ? `\`${previous.text}\`` : "the previous value"} (line ${line}).`,
+      next: `add \`,\` right after it, on line ${line}.`,
+      fixes: [{ id: "insert-comma", title: "Insert comma", safe: true, edits: [{ offset: valueEnd, length: 0, insert: "," }], caret: valueEnd + 1 }]
+    };
+  }
+  trailingComma(comma, container, previous) {
+    const what = container.type === "{" ? "property" : "item";
+    this.add({
+      code: "trailing-comma",
+      range: this.range(comma.start, comma.end),
+      path: [...container.path],
+      message: previous ? `Trailing comma after \`${previous.text}\`. JSON does not allow a comma after the last ${what}.` : "Trailing comma. JSON does not allow a comma here.",
+      next: "remove the comma.",
+      fixes: [{ id: "remove-comma", title: "Remove comma", safe: true, edits: [{ offset: comma.start, length: comma.end - comma.start, insert: "" }] }]
+    });
+  }
+  doubleComma(comma, container, afterSomething) {
+    this.add({
+      code: "double-comma",
+      range: this.range(comma.start, comma.end),
+      path: [...container.path],
+      message: afterSomething ? "Two commas in a row." : `This comma has nothing before it in the ${container.type === "{" ? "object" : "list"}.`,
+      next: "remove the extra comma.",
+      fixes: [{ id: "remove-comma", title: "Remove comma", safe: true, edits: [{ offset: comma.start, length: comma.end - comma.start, insert: "" }] }]
+    });
+  }
+  unquotedKey(token, path) {
+    this.add({
+      code: "unquoted-key",
+      range: this.range(token.start, token.end),
+      path: [...path, token.text],
+      message: `Property names need double quotes: ${JSON.stringify(token.text)}.`,
+      next: `write ${JSON.stringify(token.text)} with quotes.`,
+      fixes: [{ id: "quote-key", title: "Quote the property name", safe: true, edits: [{ offset: token.start, length: token.end - token.start, insert: JSON.stringify(token.text) }] }]
+    });
+  }
+  unexpected(token, expected) {
+    this.add({
+      code: "invalid-symbol",
+      range: this.range(token.start, token.end),
+      message: `Unexpected \`${clip(token.text, 20)}\`. Expected ${expected} here.`,
+      next: "remove it, or add the missing punctuation before it.",
+      fixes: [{ id: "remove-token", title: `Remove ${clip(token.text, 12)}`, safe: false, edits: [{ offset: token.start, length: token.end - token.start, insert: "" }] }]
+    });
+  }
+  missingColon(keyToken, key2, path, valueFollows, container) {
+    const keyEnd = keyToken.end;
+    const shown = clip(key2, 30);
+    const removal = this.removeEntry(keyToken.start, keyEnd);
+    this.structural({
+      code: "missing-colon",
+      range: this.range(keyToken.start, keyToken.end),
+      path,
+      message: valueFollows ? `\`${shown}\` is missing a colon.` : `\`${shown}\` has no colon and value.`,
+      next: valueFollows ? "add `:` after the property name." : `write ${JSON.stringify(key2)}: and a value, or remove the property.`,
+      fixes: [
+        { id: "insert-colon", title: "Add colon", safe: valueFollows, edits: [{ offset: keyEnd, length: 0, insert: valueFollows ? ":" : ": " }], caret: keyEnd + (valueFollows ? 1 : 2) },
+        ...valueFollows ? [] : [{ id: "remove-key", title: `Remove ${JSON.stringify(key2)}`, safe: false, edits: removal }]
+      ]
+    });
+  }
+  missingValue(keyToken, colon, key2, path) {
+    const needsComma = (() => {
+      const next = this.peek();
+      return (next.kind === "string" || next.kind === "word") && this.peek(1).kind === "colon";
+    })();
+    const hint = valueHint(path);
+    const gap = this.text[colon.end] === " " || this.text[colon.end] === "	" ? 0 : 1;
+    const at2 = colon.end + (gap === 0 ? 1 : 0);
+    const edits = [{ offset: at2, length: 0, insert: `${gap ? " " : ""}${hint.insert}` }];
+    if (needsComma) edits.push({ offset: at2, length: 0, insert: "," });
+    const fixes = [{ id: "add-value", title: hint.title, safe: false, edits, caret: at2 + (gap ? 1 : 0) + hint.caret }];
+    fixes.push({ id: "remove-key", title: `Remove ${JSON.stringify(key2)}`, safe: false, edits: this.removeEntry(keyToken.start, colon.end) });
+    this.structural({
+      code: "missing-value",
+      range: this.range(keyToken.start, colon.end),
+      path,
+      message: `\`${key2}\` needs a value.`,
+      next: `${hint.next} Press Ctrl+Space after the colon for options.`,
+      fixes
+    });
+  }
+  /** The edits that remove an entry whose value is missing (key through colon), and the comma that belonged to it. */
+  removeEntry(start, end) {
+    const { text } = this;
+    const firstFrom = (offset) => {
+      let low = 0;
+      let high = this.tokens.length;
+      while (low < high) {
+        const middle = low + high >> 1;
+        if (this.tokens[middle].start < offset) low = middle + 1;
+        else high = middle;
+      }
+      return low;
+    };
+    const startIndex = firstFrom(start);
+    const before = this.tokens[startIndex - 1];
+    const firstIndex = firstFrom(end);
+    const first = this.tokens[firstIndex];
+    const second = first?.kind === "comma" ? this.tokens[firstIndex + 1] : first;
+    const entryFollows = (token) => token !== void 0 && (token.kind === "string" || token.kind === "word" && this.tokens[firstFrom(token.start) + 1]?.kind === "colon");
+    let from = start;
+    let to = end;
+    if (first?.kind === "comma") to = first.end;
+    else if (!entryFollows(second) && before?.kind === "comma") from = before.start;
+    const alone = from === start && /^[ \t]*$/.test(text.slice(lineBounds(text, start).start, start)) && /^[ \t]*$/.test(text.slice(to, lineBounds(text, Math.max(to - 1, 0)).end));
+    if (alone) {
+      const bounds = lineBounds(text, start);
+      let lineEnd = lineBounds(text, Math.max(to - 1, 0)).end;
+      if (text[lineEnd] === "\r" && text[lineEnd + 1] === "\n") lineEnd += 2;
+      else if (lineEnd < text.length) lineEnd++;
+      return [{ offset: bounds.start, length: lineEnd - bounds.start, insert: "" }];
+    }
+    return [{ offset: from, length: to - from, insert: "" }];
+  }
+  unclosed(container) {
+    const { text } = this;
+    const closer = container.type === "{" ? "}" : "]";
+    const open = container.open;
+    const last = this.last && this.last.start >= open.start ? this.last : open;
+    if (last.kind === "string" && last.terminated === false) {
+      this.mute();
+      return;
+    }
+    const dangling = last.kind === "comma" && last !== open;
+    const insertAt = dangling ? last.start : last.end;
+    const removed = dangling ? last.end - last.start : 0;
+    const sameLine = this.line(open.start) === this.line(Math.max(last.end - 1, 0));
+    const own4 = sameLine ? closer : `
+${indentOf(text, open.start)}${closer}`;
+    const inner = this.cascade.last === this.last && removed === 0 ? this.cascade.inserts : [];
+    const insert = inner.join("") + own4;
+    this.cascade = { last: this.last, inserts: [...inner, own4] };
+    const closers = insert.replace(/\s/g, "");
+    const key2 = container.path.at(-1);
+    const entry = typeof key2 === "string" ? `"${key2}": ${open.text}` : open.text;
+    const context = container.type === "{" ? firstEntryOf(text, open) : void 0;
+    const what = container.type === "{" ? "property" : "item";
+    this.add({
+      code: container.type === "{" ? "unclosed-object" : "unclosed-array",
+      range: this.range(open.start, open.end),
+      path: [...container.path],
+      message: container.type === "{" ? `The \`${entry}\` on line ${this.line(open.start)}${context ? ` (starting \`${context}\`)` : ""} is never closed.` : `The list \`${entry}\` on line ${this.line(open.start)} is never closed.`,
+      next: `add \`${closer}\` after its last ${what}${sameLine ? "" : ", on its own line"}.`,
+      fixes: [{ id: "insert-closer", title: `Insert ${closers}`, safe: false, edits: [{ offset: insertAt, length: removed, insert }], caret: insertAt + insert.length }]
+    });
+    this.mute();
+  }
+  /** A closing bracket of the other kind. With an enclosing container of its kind it ends that one (the current is unclosed); alone, it is a typo for the right one. */
+  closeMismatched(container, token) {
+    const wanted = container.type === "{" ? "[" : "{";
+    if (this.stack.some((other) => other !== container && other.type === wanted)) return false;
+    const closer = container.type === "{" ? "}" : "]";
+    const open = container.open;
+    this.take();
+    this.stack.pop();
+    this.add({
+      code: container.type === "{" ? "unclosed-object" : "unclosed-array",
+      range: this.range(open.start, open.end),
+      path: [...container.path],
+      message: `The \`${open.text}\` on line ${this.line(open.start)} is closed with \`${token.text}\`, which does not match.`,
+      next: `end it with \`${closer}\`.`,
+      fixes: [{ id: "replace-closer", title: `Replace ${token.text} with ${closer}`, safe: false, edits: [{ offset: token.start, length: token.end - token.start, insert: closer }] }]
+    });
+    return true;
+  }
+};
+function keyName(token) {
+  if (token.quote === "double" && token.terminated !== false) {
+    try {
+      return JSON.parse(token.text);
+    } catch {
+    }
+  }
+  const inner = token.text.slice(1, token.terminated === false ? void 0 : -1);
+  return inner;
+}
+function clipTrailing(value) {
+  return value.replace(/[ \t]+$/, "");
+}
+function entryText(text, start, end, kind) {
+  const raw = text.slice(start, end);
+  if (kind === "object" || kind === "array") {
+    const head = raw.slice(0, raw.indexOf(kind === "object" ? "{" : "["));
+    return clip(`${head}${kind === "object" ? "{\u2026}" : "[\u2026]"}`, 40);
+  }
+  return clip(raw, 40);
+}
+function firstEntryOf(text, open) {
+  const rest = text.slice(open.end, open.end + 200);
+  const match = /^\s*("(?:[^"\\\n]|\\.)*"\s*:\s*(?:"(?:[^"\\\n]|\\.)*"|[^\s,{}[\]]+))/.exec(rest);
+  return match?.[1] ? clip(match[1], 36) : void 0;
+}
+function jsonShort(value) {
+  const text = JSON.stringify(value);
+  return text !== void 0 && text.length <= 32 ? text : void 0;
+}
+function exampleOf(info) {
+  const example = info.examples.map(jsonShort).find((item) => item !== void 0) ?? (info.enum?.[0] ? jsonShort(info.enum[0].value) : void 0);
+  if (example) return example;
+  const type = info.types[0];
+  return type === "boolean" ? "true" : type === "number" || type === "integer" ? "1" : type === "object" ? "{ \u2026 }" : type === "array" ? "[ \u2026 ]" : '"\u2026"';
+}
+function listValues(values) {
+  const shown = values.slice(0, 5).map((entry) => String(entry.value));
+  return values.length > 5 ? `one of ${values.length} values (${shown.slice(0, 3).join(", ")}, \u2026)` : `one of ${shown.join(", ")}`;
+}
+function joinAlternatives(items) {
+  return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")}, or ${items.at(-1)}`;
+}
+var article = (word) => /^[aeiou]/i.test(word) ? "an" : "a";
+function valueHint(path) {
+  let info;
+  try {
+    info = describeField(path);
+  } catch {
+    info = void 0;
+  }
+  if (!info?.known || !info.variants.length) {
+    return { next: "write a value (text in quotes, a number, true, false, null, an object { } or a list [ ]), or remove the key.", title: 'Add ""', insert: '""', caret: 1 };
+  }
+  const phrases = [];
+  const phrased = /* @__PURE__ */ new Set();
+  const order2 = [info.primary, ...info.variants.map((_, index) => index).filter((index) => index !== info.primary)];
+  for (const index of order2) {
+    const variant = info.variants[index];
+    if (!variant || phrases.length >= HINT_FORMS_LIMIT || phrased.has(variant.type)) continue;
+    phrased.add(variant.type);
+    let phrase;
+    if (variant.enum?.length) phrase = listValues(variant.enum);
+    else if (variant.type === "string" && info.catalogKind) {
+      const example = info.examples.find((item) => typeof item === "string");
+      const name = KIND_NAMES[info.catalogKind] ?? "catalog";
+      phrase = `${article(name)} ${name} id${example ? ` such as ${JSON.stringify(example)}` : ""}`;
+    } else if (variant.type === "string") {
+      const example = info.examples.find((item) => typeof item === "string" && item.length <= 24);
+      phrase = example ? `a string such as ${JSON.stringify(example)}` : "text in double quotes";
+    } else if (variant.type === "boolean") phrase = "true or false";
+    else if (variant.type === "integer" || variant.type === "number") {
+      const example = info.examples.find((item) => typeof item === "number");
+      phrase = `a number${example !== void 0 ? ` such as ${example}` : ""}`;
+    } else if (variant.type === "object") {
+      const keyName2 = variant.requiredChildren[0] ?? info.children.find((child) => !child.advanced)?.key;
+      if (keyName2) {
+        const child = describeField([...path, keyName2]);
+        phrase = `an object such as { ${JSON.stringify(keyName2)}: ${exampleOf(child)} }`;
+      } else phrase = "an object { }";
+    } else if (variant.type === "array") {
+      const item = info.itemInfo;
+      phrase = item?.known ? `a list such as [ ${exampleOf(item)} ]` : "a list [ ]";
+    }
+    if (phrase && !phrases.includes(phrase)) phrases.push(phrase);
+  }
+  const primary = info.variants[info.primary];
+  const next = `${joinAlternatives([...phrases, "remove the key"])}.`;
+  let title = 'Add ""';
+  let insert = '""';
+  let caret = 1;
+  if (primary?.type === "object") {
+    title = "Add { }";
+    insert = "{}";
+    caret = 1;
+  } else if (primary?.type === "array") {
+    title = "Add [ ]";
+    insert = "[]";
+    caret = 1;
+  } else if (primary?.enum?.length) {
+    const value = JSON.stringify(primary.enum[0]?.value);
+    title = `Add ${value}`;
+    insert = value;
+    caret = value.length;
+  } else if (primary?.type === "boolean") {
+    title = "Add false";
+    insert = "false";
+    caret = insert.length;
+  } else if (primary?.type === "integer" || primary?.type === "number") {
+    let value = "0";
+    try {
+      const made = createSchemaValue(schemaAtPath({}, path));
+      if (typeof made === "number") value = String(made);
+    } catch {
+    }
+    title = `Add ${value}`;
+    insert = value;
+    caret = insert.length;
+  }
+  return { next, title, insert, caret };
 }
+function analyzeJsonSyntax(text, options = {}) {
+  const limit = Math.max(0, options.limit ?? 5);
+  const analyzer = new Analyzer(String(text ?? ""));
+  try {
+    analyzer.run();
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return analyzer.problems.sort((a, b) => a.problem.range.offset - b.problem.range.offset || a.order - b.order).map((entry) => entry.problem).filter((problem) => {
+    const id = `${problem.code}:${problem.range.offset}`;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  }).slice(0, limit);
+}
+
+// src/check-source.ts
 function parseSource(source) {
   const errors = [], tree = parseTree(
     source.startsWith("\uFEFF") ? " " + source.slice(1) : source,
@@ -3494,35 +5228,22 @@ function parseSource(source) {
       allowEmptyContent: false
     }
   );
-  const lineStarts = [0];
-  for (let i = 0; i < source.length; i++) {
-    if (source[i] === "\r") {
-      if (source[i + 1] === "\n") i++;
-      lineStarts.push(i + 1);
-    } else if (source[i] === "\n") lineStarts.push(i + 1);
-  }
-  const location = (offset, length) => {
-    let lo = 0, hi = lineStarts.length;
-    while (lo + 1 < hi) {
-      const mid = lo + hi >> 1;
-      if ((lineStarts[mid] ?? 0) <= offset) lo = mid;
-      else hi = mid;
-    }
-    return {
-      offset,
-      length,
-      line: lo + 1,
-      column: offset - (lineStarts[lo] ?? 0) + 1
-    };
-  };
+  const location = createLocator(source);
   if (errors.length || !tree) {
-    const note = hint(source);
+    const problems = analyzeJsonSyntax(source);
     return {
-      syntax: errors.map(
-        (error, index) => finding("opf/json-syntax", {
+      syntax: problems.length ? problems.map(
+        (problem) => finding("opf/json-syntax", {
+          path: "",
+          message: problem.message,
+          help: problem.next,
+          location: problem.range
+        })
+      ) : errors.map(
+        (error) => finding("opf/json-syntax", {
           path: "",
           message: printParseErrorCode(error.error),
-          help: `Repair the JSON syntax at this source range. No content or whitespace has been rewritten.${index === 0 ? note : ""}`,
+          help: "Repair the JSON syntax at this source range. No content or whitespace has been rewritten.",
           location: location(error.offset, error.length)
         })
       ),
@@ -3611,14 +5332,14 @@ function slideScriptMeasurement(presentation, slideIndex, measurement, options)
   const forLanguage = (lang) => {
     if (typeof lang !== "string" || !lang) return void 0;
     if (!languages.has(lang)) {
-      let own2;
+      let own4;
       try {
         const profile = scriptProfile(presentation, slideIndex, options, lang);
-        own2 = profile.languageSource === "option" && profile.bcp47?.toLowerCase() !== deckProfile.bcp47?.toLowerCase() ? forScripts.call(measurement, profile) : void 0;
+        own4 = profile.languageSource === "option" && profile.bcp47?.toLowerCase() !== deckProfile.bcp47?.toLowerCase() ? forScripts.call(measurement, profile) : void 0;
       } catch {
-        own2 = void 0;
+        own4 = void 0;
       }
-      languages.set(lang, own2);
+      languages.set(lang, own4);
     }
     return languages.get(lang);
   };
@@ -3627,8 +5348,8 @@ function slideScriptMeasurement(presentation, slideIndex, measurement, options)
   if (typeof deck.resolveStyle === "function") scripted.resolveStyle = (style) => deck.resolveStyle.call(deck, style);
   if (typeof deck.outlineBounds === "function")
     scripted.outlineBounds = (text, size, style) => {
-      const own2 = pick(style);
-      return typeof own2.outlineBounds === "function" ? own2.outlineBounds(text, size, style) : deck.outlineBounds.call(deck, text, size, style);
+      const own4 = pick(style);
+      return typeof own4.outlineBounds === "function" ? own4.outlineBounds(text, size, style) : deck.outlineBounds.call(deck, text, size, style);
     };
   return scripted;
 }
@@ -3700,15 +5421,15 @@ var lazy = (compute) => {
 };
 function relax(value) {
   const copy = JSON.parse(JSON.stringify(value));
-  const walk = (node) => {
-    if (Array.isArray(node)) return node.forEach(walk);
+  const walk2 = (node) => {
+    if (Array.isArray(node)) return node.forEach(walk2);
     if (node && typeof node === "object") {
       const object2 = node;
       if (object2.overflow === "error") object2.overflow = "warn";
-      for (const child of Object.values(object2)) walk(child);
+      for (const child of Object.values(object2)) walk2(child);
     }
   };
-  walk(copy);
+  walk2(copy);
   return copy;
 }
 function buildSlides(document, options) {
@@ -3776,7 +5497,7 @@ function buildSlides(document, options) {
 var SEVERITIES = ["error", "warning", "info"];
 var OPTION_KEYS = ["only", "ignore", "severity", "ignorePaths", "catalogs", "contracts", "thresholds", "fonts", "chartPalette", "template", "values"];
 var DOCS = "https://github.com/OpenPresentation/opf/blob/main/docs/validate.md";
-var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var OPFValidationError = class extends Error {
   /** The full report that failed. */
   report;
@@ -3809,14 +5530,14 @@ function names(list, what) {
   return result;
 }
 function resolveOptions(options) {
-  if (!isObject(options)) throw new TypeError("Validate options must be an object.");
+  if (!isObject2(options)) throw new TypeError("Validate options must be an object.");
   for (const key2 of Object.keys(options)) if (!OPTION_KEYS.includes(key2)) throw new TypeError(`Unknown validate option ${JSON.stringify(key2)}. Options: ${OPTION_KEYS.join(", ")}.`);
   checkDocumentOptions(options);
   const only = names(options.only, "only");
   const ignore = names(options.ignore, "ignore");
   const severity = /* @__PURE__ */ new Map();
   if (options.severity !== void 0) {
-    if (!isObject(options.severity)) throw new TypeError('Validate severity must map rule ids or category names to a severity or "off".');
+    if (!isObject2(options.severity)) throw new TypeError('Validate severity must map rule ids or category names to a severity or "off".');
     for (const [name, value] of Object.entries(options.severity)) {
       if (typeof value !== "string" || value !== "off" && !SEVERITIES.includes(value)) throw new TypeError(`Validate severity for ${JSON.stringify(name)} must be error, warning, info or off.`);
       const found = ruleFor(name, "severity");
@@ -3827,7 +5548,7 @@ function resolveOptions(options) {
   if (options.ignorePaths !== void 0) {
     if (!Array.isArray(options.ignorePaths)) throw new TypeError("Validate ignorePaths must be an array of {rule, path}.");
     for (const entry of options.ignorePaths) {
-      if (!isObject(entry) || typeof entry.rule !== "string" || typeof entry.path !== "string" || entry.path !== "" && !entry.path.startsWith("/"))
+      if (!isObject2(entry) || typeof entry.rule !== "string" || typeof entry.path !== "string" || entry.path !== "" && !entry.path.startsWith("/"))
         throw new TypeError('Each validate ignorePaths entry needs a rule id, category name or "*", and a JSON Pointer path.');
       const found = entry.rule === "*" ? "*" : ruleFor(entry.rule, "ignorePaths");
       ignorePaths.push({
@@ -3838,7 +5559,7 @@ function resolveOptions(options) {
   }
   const thresholds = { ...DEFAULT_VALIDATION_THRESHOLDS };
   if (options.thresholds !== void 0) {
-    if (!isObject(options.thresholds)) throw new TypeError("Validate thresholds must be an object.");
+    if (!isObject2(options.thresholds)) throw new TypeError("Validate thresholds must be an object.");
     for (const [key2, value] of Object.entries(options.thresholds)) {
       if (!(key2 in DEFAULT_VALIDATION_THRESHOLDS)) throw new TypeError(`Unknown validate threshold ${JSON.stringify(key2)}. Thresholds: ${Object.keys(DEFAULT_VALIDATION_THRESHOLDS).join(", ")}.`);
       if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`Validate threshold ${key2} must be a positive number.`);
@@ -3846,14 +5567,14 @@ function resolveOptions(options) {
     }
   }
   if (options.fonts !== void 0) {
-    if (!isObject(options.fonts)) throw new TypeError("Validate fonts must be a fonts object with a textMeasurement.");
+    if (!isObject2(options.fonts)) throw new TypeError("Validate fonts must be a fonts object with a textMeasurement.");
     const measurement = options.fonts.textMeasurement;
-    if (measurement !== void 0 && typeof measurement !== "function" && !isObject(measurement)) throw new TypeError("Validate fonts.textMeasurement must be a text measurement, or a function of the slide index.");
+    if (measurement !== void 0 && typeof measurement !== "function" && !isObject2(measurement)) throw new TypeError("Validate fonts.textMeasurement must be a text measurement, or a function of the slide index.");
   }
   if (options.chartPalette !== void 0 && (!Array.isArray(options.chartPalette) || !options.chartPalette.every((color) => typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color))))
     throw new TypeError("Validate chartPalette must be an array of #RRGGBB colours.");
   if (options.template !== void 0 && typeof options.template !== "boolean") throw new TypeError("Validate template must be true or false.");
-  if (options.values !== void 0 && !isObject(options.values)) throw new TypeError("Validate values must be an object keyed by variable id.");
+  if (options.values !== void 0 && !isObject2(options.values)) throw new TypeError("Validate values must be an object keyed by variable id.");
   const level = (info) => severity.get(info.id) ?? severity.get(info.category);
   const off = (info) => level(info) === "off" || !!ignore?.rules.has(info.id) || !!ignore?.categories.has(info.category);
   return {
@@ -3910,7 +5631,7 @@ function syntaxReport(parsed, run) {
 function validateDocument(document, run, parsed) {
   const engine = validateAgainstSchema(document, "presentation", { template: run.options.template, values: run.options.values, ...run.options.catalogs ? { catalogs: run.options.catalogs } : {} });
   const schemaValid = engine.errors.length === 0;
-  const slides = isObject(document) && Array.isArray(document.slides) ? document.slides : [];
+  const slides = isObject2(document) && Array.isArray(document.slides) ? document.slides : [];
   const auditWanted = auditInfos.some((info) => run.enabled(info));
   const explainFormat = !schemaValid && auditWanted;
   const enabledRule = (info) => info ? run.enabled(info) || explainFormat && info.category === "format" && !run.off(info) : true;
@@ -3975,7 +5696,7 @@ function validateDocument(document, run, parsed) {
     if (info && run.ignored(info, splitPointer(next.path))) continue;
     const index = slideOf(next.path);
     if (next.slide === void 0 && index !== void 0 && next.scope !== "context") {
-      const id = isObject(slides[index]) ? slides[index].id : void 0;
+      const id = isObject2(slides[index]) ? slides[index].id : void 0;
       next.slide = index;
       if (typeof id === "string") next.slideId = id;
     }
@@ -4046,4 +5767,4 @@ function assertValidCatalogRecord(kind, value) {
   if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { CATALOG_SCHEMA, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogSchemaNames, findValidationRule, parseSource, resolveSlideContext, resolveSlideScriptMeasurement, validate, validateCatalogRecord, validationCategories, validationRules };
+export { CATALOG_SCHEMA, COMMON_KEYS, DEFAULT_VALIDATION_THRESHOLDS, OPFPatchError, OPFPatchValidationError, OPFValidationError, UNRANKED_PRIORITY, activeSchema, analyzeJsonSyntax, applyPatch, applyPatchWithInverse, applyTextEdits, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogKindAt, catalogSchemaNames, createLocator, createSchemaValue, describeField, escapePointerToken, findValidationRule, formatPointer, getAtPointer, hasPointer, invertPatch, isPromotedRegionKey, jsonEqual, listSchemaFields, normalizePatch, parsePointer, parseSource, pointerFromPath, readPointer, resolveSchema, resolveSlideContext, resolveSlideScriptMeasurement, schemaAtPath, schemaLabel, schemaType, schemaVariants, splitOpfPath, splitPointer2 as splitPointer, unescapePointerToken, validate, validateCatalogRecord, validationCategories, validationRules };