@openpresentation/opf 0.15.1 → 0.17.0

package/dist/{chunk-3RKB4RDJ.js → chunk-IS5H5JKH.js}

@@ -1,6 +1,8 @@
-import { isRecord, same } from './chunk-VGAOJEY7.js';
+import { isRecord, same } from './chunk-PPROJP2E.js';
 import { parseDocument, YAMLMap, Scalar, stringify } from 'yaml';
 
+// src/not-checked.ts
+var NOT_CHECKED = { syntax: "checked", schema: "not-run", references: "not-run", policy: "not-run", accessibility: "not-run", content: "not-run", layout: "not-run", backgroundPixels: "not-read", imageBytes: "embedded-only", nativeExport: "not-checked" };
 function splitLines(source) {
   const lines = [];
   let start = 0;
@@ -189,4 +191,4 @@ var OPFMarkdownError = class extends Error {
   }
 };
 
-export { Ctx, DECIMAL, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };
+export { Ctx, DECIMAL, NOT_CHECKED, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };

package/dist/{chunk-TWQJLI6E.js → chunk-M4UR3NPN.js}

@@ -1,5 +1,5 @@
-import { jsonEqual, formatPointer } from './chunk-5FTUIDUH.js';
-import { annotationText } from './chunk-O744SXXA.js';
+import { jsonEqual, formatPointer } from './chunk-O3CVNJTL.js';
+import { annotationText } from './chunk-CW7GEAV3.js';
 
 // src/diff-match.ts
 var DEFAULT_MATCH_THRESHOLD = 0.5;

package/dist/chunk-N4EVOFEA.js

@@ -0,0 +1,58 @@
+import { fromMarkdown, toMarkdown } from './chunk-BIC3SWPK.js';
+import { fromYaml, toYaml } from './chunk-TCD2FB2K.js';
+import { NOT_CHECKED } from './chunk-IS5H5JKH.js';
+import { parseSource, validate, OPFValidationError } from './chunk-NLNYNBTS.js';
+import { checkCatalogsOption } from './chunk-SPFV27O5.js';
+
+// src/deck-report.ts
+var DECK_FORMATS = ["json", "yaml", "markdown"];
+function deckFormatOf(filename) {
+  if (filename === void 0) return "json";
+  if (/\.opf\.md$/i.test(filename)) return "markdown";
+  if (/\.ya?ml$/i.test(filename)) return "yaml";
+  return "json";
+}
+function resolveFormat(caller, options) {
+  if (options.format === void 0) return deckFormatOf(options.filename);
+  if (!DECK_FORMATS.includes(options.format)) throw new TypeError(`${caller}: unknown format ${JSON.stringify(options.format)}. Formats: ${DECK_FORMATS.join(", ")}.`);
+  return options.format;
+}
+function readDeckReport(text, options = {}, caller = "parse") {
+  if (typeof text !== "string") throw new TypeError(`${caller} expects a string.`);
+  checkCatalogsOption(options.catalogs, caller);
+  const format = resolveFormat(caller, options);
+  const { catalogs } = options;
+  const check = options.validate ?? true;
+  const validateOptions = typeof check === "object" ? { ...catalogs && check.catalogs === void 0 ? { catalogs } : {}, ...check } : { only: ["format", "references"], ...catalogs ? { catalogs } : {} };
+  const checked = check === false ? false : validateOptions;
+  if (format === "yaml") return { ...fromYaml(text, { validate: checked, catalogs }), format };
+  if (format === "markdown") return { ...fromMarkdown(text, { validate: checked, catalogs }), format };
+  if (checked === false) {
+    const parsed = parseSource(text);
+    return { ...report(parsed.syntax), presentation: parsed.syntax.length ? {} : parsed.value, format };
+  }
+  const result = validate(text, checked);
+  const broken = result.findings.some((found) => found.ruleId === "opf/json-syntax");
+  return { ...result, presentation: broken ? {} : JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text), format };
+}
+function report(findings) {
+  const counts = { error: 0, warning: 0, info: 0 };
+  for (const found of findings) counts[found.severity]++;
+  return { valid: counts.error === 0, schemaValid: null, findings, counts, checks: NOT_CHECKED };
+}
+
+// src/deck.ts
+function parse(text, options = {}) {
+  const { presentation, format: _format, ...result } = readDeckReport(text, { ...options, validate: true }, "parse");
+  if (!result.valid) throw new OPFValidationError(result);
+  return presentation;
+}
+function stringify(presentation, options = {}) {
+  const format = resolveFormat("stringify", options);
+  if (format === "yaml") return toYaml(presentation, { schemaComment: options.schemaComment === true }).yaml;
+  if (format === "markdown") return toMarkdown(presentation).markdown;
+  return `${JSON.stringify(presentation, null, 2)}
+`;
+}
+
+export { DECK_FORMATS, deckFormatOf, parse, readDeckReport, stringify };

package/dist/{chunk-QDI75P2M.js → chunk-NLNYNBTS.js}

@@ -1,7 +1,7 @@
-import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, imageBackground, tableGrid, timelineTextColor, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveDesignRecords, resolveColorRoles, resolveFontFamilies, resolveCanvasDimensions, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, OPFCompositionError, composeSlide, resolveScriptFonts } from './chunk-O744SXXA.js';
+import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, imageBackground, tableGrid, timelineTextColor, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveDesignRecords, resolveFontFamilies, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, resolveScriptFonts, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, MAX_PLACEHOLDER_GROUP_DEPTH, OPFCompositionError, composeSlide } from './chunk-CW7GEAV3.js';
 import { catalogSchemaNames } from './chunk-TRDXRRQK.js';
 import { resolveReference, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, catalogRecords, catalogKinds, catalogGroupSource, registeredCatalog } from './chunk-SPFV27O5.js';
-import { schemaEntries, schemas } from './chunk-2CJPC4HI.js';
+import { schemaEntries, schemas } from './chunk-RA64UQKI.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
@@ -864,6 +864,33 @@ function dataUnionErrors(errors, value) {
     return { ...error, message: field === "fields" ? "'fields' applies only to a dataset-backed table; add 'dataset' or remove 'fields'" : datasetTableMessage(field) };
   });
 }
+var placeholderHeadings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
+function placeholderGroupIssues(value) {
+  const issues = [];
+  if (!isRecord(value) || !Array.isArray(value.placeholders)) return issues;
+  const walk = (entries, path, depth) => entries.forEach((entry, index) => {
+    if (!isRecord(entry)) return;
+    const at2 = `${path}/${index}`;
+    if (entry.type === "group") {
+      if (depth >= MAX_PLACEHOLDER_GROUP_DEPTH) issues.push(semanticIssue(at2, `placeholder groups nest at most ${MAX_PLACEHOLDER_GROUP_DEPTH} levels inside a layout record; this group would be level ${depth + 1}`, { code: "layout-placeholder-group", depth: depth + 1, maxDepth: MAX_PLACEHOLDER_GROUP_DEPTH }));
+      else if (Array.isArray(entry.placeholders)) walk(entry.placeholders, `${at2}/placeholders`, depth + 1);
+      return;
+    }
+    if (depth === 0) return;
+    if (typeof entry.type === "string" && placeholderHeadings.has(entry.type)) issues.push(semanticIssue(`${at2}/type`, `a placeholder group holds body regions only; a '${entry.type}' placeholder belongs at the record's top level`, { code: "layout-placeholder-group" }));
+    if (hasOwn(entry, "placement")) issues.push(semanticIssue(`${at2}/placement`, "placement is only valid on a top-level image placeholder; a region inside a placeholder group cannot bleed to a slide edge", { code: "image-placement-invalid" }));
+  });
+  walk(value.placeholders, "/placeholders", 0);
+  return issues;
+}
+function withPlaceholderGroupIssues(errors, value) {
+  const issues = placeholderGroupIssues(value);
+  const entries = issues.map((issue2) => issue2.path.replace(/\/(type|placement)$/, ""));
+  const covered = (error) => entries.some((entry) => error.path === entry || error.path.startsWith(`${entry}/`));
+  const kept = errors.filter((error) => !covered(error));
+  const reported = [...kept.filter((error) => error.keyword !== "if"), ...issues].map((error) => error.path);
+  return [...kept.filter((error) => error.keyword !== "if" || !reported.some((path) => path === error.path || path.startsWith(`${error.path}/`))), ...issues];
+}
 function validateAgainstSchema(value, schemaOrKind = "presentation", options = {}) {
   const resolved = resolveValidator(schemaOrKind);
   if (resolved.schemaName === "presentation") {
@@ -895,7 +922,8 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options = {
   }
   const valid = resolved.validate(subject) === true;
   const ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
-  const errors = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
+  const mapped = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
+  const errors = resolved.schemaName === "layout" ? withPlaceholderGroupIssues(mapped, subject) : mapped;
   const warnings = [];
   if (resolved.schemaName === "presentation") {
     errors.push(...presentationSemanticIssues(subject));
@@ -1918,7 +1946,7 @@ var languageRule = rule(
   "info",
   "The presentation does not declare its language.",
   "Screen readers and text-to-speech choose pronunciation and hyphenation from the declared language; spell checkers and translation tools use it too.",
-  { standard: "WCAG 2.2 SC 3.1.1 Language of Page, level A", approximations: "Only the presentation-level `language` is checked, not the language of individual runs (OPF has no per-run language)." }
+  { standard: "WCAG 2.2 SC 3.1.1 Language of Page, level A", approximations: "Only the presentation-level `language` is checked, not the language of individual runs (`TextRun.lang`; opf/language-tag checks how those tags are written)." }
 );
 var languageRules = [
   {
@@ -1944,6 +1972,105 @@ var accessibilityRules = [
   ...languageRules
 ];
 
+// src/language-tag.ts
+var REGION_ALIASES = { UK: "GB" };
+var privateRegion = /^(?:AA|Q[M-Z]|X[A-Z]|ZZ)$/;
+var regionNames;
+var assignedRegion = (region) => {
+  if (privateRegion.test(region)) return true;
+  regionNames ??= new Intl.DisplayNames(["en"], { type: "region", fallback: "code" });
+  try {
+    return regionNames.of(region) !== region;
+  } catch {
+    return false;
+  }
+};
+var canonical = (tag) => {
+  try {
+    return Intl.getCanonicalLocales(tag)[0];
+  } catch {
+    return void 0;
+  }
+};
+function regionSubtag(tag) {
+  const subtags = tag.split("-");
+  for (let index = 1; index < subtags.length; index++) {
+    const subtag = subtags[index];
+    if (/^(?:[a-z]{2}|\d{3})$/i.test(subtag)) return { region: subtag.toUpperCase(), index };
+    if (!/^[a-z]{3,4}$/i.test(subtag)) return void 0;
+  }
+  return void 0;
+}
+function languageTagProblem(tag) {
+  if (/^[ix]-/i.test(tag)) return void 0;
+  const parsed = canonical(tag);
+  if (parsed === void 0) return { message: `'${tag}' is not a well-formed BCP 47 language tag (subtags are letters and digits joined by hyphens, such as 'en-US' or 'zh-Hans').`, caseOnly: false };
+  const found = regionSubtag(tag);
+  if (found) {
+    const alias = REGION_ALIASES[found.region];
+    if (alias || !assignedRegion(found.region)) {
+      const subtags = tag.split("-");
+      subtags[found.index] = alias ?? found.region;
+      const suggestion = alias ? canonical(subtags.join("-")) : void 0;
+      return {
+        message: `'${tag}' names the region '${found.region}', which is not an assigned region${suggestion ? `; '${suggestion}' is the tag for ${new Intl.DisplayNames(["en"], { type: "region" }).of(alias)}` : ""}.`,
+        ...suggestion ? { suggestion } : {},
+        caseOnly: false
+      };
+    }
+  }
+  if (parsed === tag) return void 0;
+  if (parsed.toLowerCase() === tag.toLowerCase())
+    return { message: `'${tag}' is not in canonical case; the canonical form is '${parsed}' (language lower case, script title case, region upper case).`, suggestion: parsed, caseOnly: true };
+  const replacement = found && regionSubtag(parsed)?.region;
+  if (found && replacement && replacement !== found.region) {
+    const subtags = tag.split("-");
+    subtags[found.index] = replacement;
+    return { message: `'${tag}' names the region '${found.region}', which is deprecated; use '${replacement}'.`, suggestion: subtags.join("-"), caseOnly: false };
+  }
+  return void 0;
+}
+
+// src/rules-language.ts
+var languageTagRule = rule(
+  "language-tag",
+  "content",
+  "warning",
+  "A language tag is malformed, uses an unassigned region or is not in canonical case.",
+  "Engines read the deck language and each run's `lang` as BCP 47 tags to choose script fonts, text direction, proofing language and the PowerPoint `lang` attribute. A tag such as `en-a`, or a region that does not exist (`en-UK`; the United Kingdom is `GB`), is guessed at or dropped, and a wrong-case tag (`EN-us`) is not what a locale lookup expects.",
+  {
+    standard: "BCP 47 (RFC 5646, section 2.1) and the platform locale data (Intl.getCanonicalLocales, Intl.DisplayNames)",
+    approximations: "Checks the root `language` (a tag string, or the `bcp47` of an inline Language object) and `lang` on the TextRun objects of titles, subtitles, tags, text, lists, tables, quotes, metrics and timelines. A region is assigned when the runtime's CLDR data names it (ISO 3166-1 codes and UN M.49 areas such as 419); private-use regions (`AA`, `QM`-`QZ`, `XA`-`XZ`) and `ZZ` are accepted, as are private-use (`x-...`) tags. Only the spelling of a tag is checked, not whether the language subtag is assigned or whether the language suits the text. The schema rejects tags with characters other than letters, digits and hyphens (`en_US` is a schema error, with no suggestion), and `en-UK` as the deck language is already an error of the schema rule, so those are not reported twice."
+  }
+);
+var report = (context, tag, path, slide) => {
+  if (typeof tag !== "string") return;
+  const problem = languageTagProblem(tag);
+  if (!problem) return;
+  context.report(languageTagRule, {
+    path,
+    slide,
+    message: problem.message,
+    help: problem.suggestion ? `Write '${problem.suggestion}'.` : 'Write a well-formed BCP 47 tag with an assigned region, such as "en-US", "pt-BR" or "es-419".',
+    ...problem.suggestion ? { fixes: [{ id: "use-canonical-tag", title: `Use '${problem.suggestion}'`, kind: "patch", safe: problem.caseOnly, patch: [{ op: "replace", path, value: problem.suggestion }] }] } : {}
+  });
+};
+var isEnUk = (tag) => typeof tag === "string" && tag.toLowerCase() === "en-uk";
+var languageTagRules = [
+  {
+    info: languageTagRule,
+    run(context) {
+      const language = context.document.language;
+      if (typeof language === "string") {
+        if (!isEnUk(language)) report(context, language, "/language");
+      } else if (language !== void 0 && !isEnUk(rec(language).bcp47)) report(context, rec(language).bcp47, "/language/bcp47");
+      for (const slide of context.slides)
+        for (const tv of slide.texts)
+          if (typeof tv.value !== "string") for (const run of runsOf(tv)) report(context, run.style.lang, `${run.path}/lang`, slide);
+    }
+  }
+];
+
 // src/rules-layout-content.ts
 var PX_TO_PT2 = 0.75;
 var round2 = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
@@ -2287,13 +2414,14 @@ var formatRules = [
   rule("caption-unsupported-payload", "format", "error", "A caption is on a payload that cannot carry one.", "A caption belongs to exactly one image, chart, table or video; a group, text or code block has no place to draw it.", { standard: SCHEMA }),
   rule("image-option-unsupported-payload", "format", "error", "An image option is on a payload that is not an image.", "`fit`, `focus`, the image treatments (`shape`, `cornerRadius`, `border`, `opacity`, `recolor`, `overlay`, `aspectRatio`) and `placement` describe how a picture is drawn; a group, text or chart block has no picture for them to apply to.", { standard: SCHEMA }),
   rule("image-placement-invalid", "format", "error", "An image placement cannot be honoured.", "A placed image bleeds to a slide edge and the rest of the slide composes beside it. Only a top-level block (slides.N.blocks.I) can do that, and a slide edge holds one placed image; a block in a group or a promoted region, or a second block on the same edge, has nowhere to go.", { standard: SCHEMA }),
+  rule("layout-placeholder-group", "format", "error", "A layout record's placeholder group breaks a nesting rule.", "A placeholder group arranges body regions inside one cell of its layout record. Groups nest at most three levels inside a record, and a group holds body regions and groups only: the headings (title, subtitle, tag) stay at the record's top level, where the engine places them. Composition cannot use a record that breaks either rule.", { standard: SCHEMA }),
   rule("dataset-unknown", "format", "error", "A chart or table names a dataset that does not exist.", "The data cannot be drawn without the dataset it refers to.", { standard: SCHEMA }),
   rule("dataset-field-unknown", "format", "error", "A table asks a dataset for a column it does not have.", "The column cannot be shown when the dataset has no column of that name.", { standard: SCHEMA }),
   rule("data-column-duplicate", "format", "error", "A dataset or table has two columns with the same name.", "Series, mappings and fields address columns by name, so a repeated name makes them ambiguous.", { standard: SCHEMA }),
   rule("chart-mapping-unknown-column", "format", "error", "A chart mapping names a column the data does not have.", "The series cannot be built from a column that is not there.", { standard: SCHEMA }),
   rule("number-format-invalid", "format", "error", "A number format cannot be read.", "A format code that no engine can parse is drawn as the plain number or fails to export.", { standard: "Excel number format codes, as far as OPF supports them" }),
   rule("variable-invalid-value", "format", "error", "A variable value does not match its declared type.", "A number variable given text, or a date given a non-date, cannot be filled into the deck.", { standard: SCHEMA }),
-  rule("variable-unknown-builtin", "format", "error", "A token names a built-in variable that does not exist.", "The `deck.`, `speaker.` and `organization.` names (and `speakers`) are reserved for built-in variables; a name under them that is not a built-in can never be filled, so the token would show literally.", { standard: SCHEMA }),
+  rule("variable-unknown-builtin", "format", "error", "A token names a built-in variable that does not exist.", "The `deck.`, `speaker.`, `organization.` and `slide.` names (and `speakers`) are reserved for built-in variables; a name under them that is not a built-in can never be filled, so the token would show literally. The slide-scoped `slide.number`, `slide.section` and `deck.slideCount` are inline tokens only, so `var:slide.*` and `var:deck.slideCount` are reported too.", { standard: SCHEMA }),
   rule("chart-highlight-unknown-name", "format", "error", "A chart highlight names a series or category the chart does not have.", "`chart.highlight` emphasises marks by name; a name that matches no series or category in the chart data highlights nothing, so the chart is not drawn as authored.", { standard: SCHEMA }),
   rule("variable-format", "format", "error", "A variable cannot be formatted.", "A number or date format that does not apply to the value leaves the token unreadable.", { standard: SCHEMA }),
   rule(
@@ -2377,11 +2505,11 @@ var dataRules = [
   rule("chart-highlight-adapted", "content", "warning", "A chart highlight is adapted by the chart type.", "A highlight the chart type cannot show as authored (a category highlight on a chart without categories, for example) is adapted by every engine, so the emphasis is not exactly what was written.", { standard: SCHEMA }),
   rule("code-highlight-out-of-range", "content", "warning", "A code highlight marks a line the code does not have.", "Marked lines count from 1 by line break in code.source; an entry past the last line marks nothing.", { standard: SCHEMA }),
   rule("code-highlight-range-reversed", "content", "warning", "A code highlight range ends before it starts.", "A range written end before start marks nothing; write the smaller line number first.", { standard: SCHEMA }),
-  rule("variable-builtin-missing", "content", "warning", "A built-in variable has no value in this document.", "A `{{deck.*}}`, `{{speaker.*}}` or `{{organization.*}}` token whose field the document does not set resolves to nothing, so the text shows a gap.", { standard: SCHEMA }),
+  rule("variable-builtin-missing", "content", "warning", "A built-in variable has no value in this document.", "A `{{deck.*}}`, `{{speaker.*}}` or `{{organization.*}}` token whose field the document does not set resolves to nothing, so the text shows a gap. `{{slide.section}}` is checked per slide: a slide without a `section` that uses it, in its own text or in the header or footer it inherits, is reported at that slide.", { standard: SCHEMA }),
   rule("duration-outside-narrative", "content", "warning", "The target duration is outside the range the narrative suits.", "A narrative records the talk lengths it suits. A deck whose duration is outside that range probably needs a different narrative or a different length; nothing is drawn or exported differently.", { standard: SCHEMA }),
   rule("narrative-duration-range", "content", "warning", "An inline narrative duration range has min greater than max.", "A range with its bounds swapped matches no duration, so the duration check cannot help.", { standard: "spec/schemas/narrative.schema.json" })
 ];
-var implementations = [...accessibilityRules, ...layoutContentRules];
+var implementations = [...accessibilityRules, ...layoutContentRules, ...languageTagRules];
 var ruleImplementations = implementations;
 var infos = [
   ...formatRules,
@@ -3117,6 +3245,67 @@ function parseSource(source) {
   };
 }
 
+// src/script-measurement.ts
+function scriptProfile(presentation, slideIndex, options, language) {
+  let resolved;
+  try {
+    resolved = resolveScriptFonts(presentation, { slideIndex, ...options.catalogs !== void 0 ? { catalogs: options.catalogs } : {}, ...language === void 0 ? {} : { language } });
+  } catch {
+    resolved = void 0;
+  }
+  const slots = (role) => {
+    const latin = options.fontFamilies[role];
+    const slot = (key) => !resolved || resolved.sources[key] === "latin" || resolved.sources[key] === "schemeFamily" ? latin : resolved[role][key] ?? latin;
+    return { latin, eastAsian: slot("eastAsian"), complexScript: slot("complexScript") };
+  };
+  return {
+    heading: slots("heading"),
+    body: slots("body"),
+    ...resolved?.supplement ? { supplement: resolved.supplement } : {},
+    script: resolved?.script ?? "Zzzz",
+    ...resolved ? { scriptRole: resolved.scriptRole, bcp47: resolved.bcp47, lang: resolved.lang, languageSource: resolved.languageSource, direction: resolved.direction } : {},
+    rtl: resolved?.rtl === true,
+    serif: options.serif
+  };
+}
+function slideScriptMeasurement(presentation, slideIndex, measurement, options) {
+  const forScripts = measurement.forScripts;
+  if (typeof forScripts !== "function") return measurement;
+  const deckProfile = scriptProfile(presentation, slideIndex, options);
+  const deck = forScripts.call(measurement, deckProfile);
+  const languages = /* @__PURE__ */ new Map();
+  const forLanguage = (lang) => {
+    if (typeof lang !== "string" || !lang) return void 0;
+    if (!languages.has(lang)) {
+      let own2;
+      try {
+        const profile = scriptProfile(presentation, slideIndex, options, lang);
+        own2 = profile.languageSource === "option" && profile.bcp47?.toLowerCase() !== deckProfile.bcp47?.toLowerCase() ? forScripts.call(measurement, profile) : void 0;
+      } catch {
+        own2 = void 0;
+      }
+      languages.set(lang, own2);
+    }
+    return languages.get(lang);
+  };
+  const pick = (style) => forLanguage(style?.lang) ?? deck;
+  const scripted = { ...deck, measure: (text, size, style) => pick(style).measure(text, size, style) };
+  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);
+    };
+  return scripted;
+}
+function resolveSlideScriptMeasurement(presentation, slideIndex, measurement, options = {}) {
+  if (typeof measurement.forScripts !== "function") return measurement;
+  const { fontScheme } = resolveDesignRecords(presentation, slideIndex, options.catalogs !== void 0 ? { catalogs: options.catalogs } : {});
+  const resolved = resolveFontFamilies(fontScheme);
+  const fontFamilies = { heading: options.fontFamilies?.heading ?? resolved.heading, body: options.fontFamilies?.body ?? resolved.body };
+  return slideScriptMeasurement(presentation, slideIndex, measurement, { ...options.catalogs !== void 0 ? { catalogs: options.catalogs } : {}, fontFamilies, serif: fontScheme.type === "serif" });
+}
+
 // src/slide-context.ts
 var rec2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function resolveSlideContext(presentation, index, options = {}) {
@@ -3152,7 +3341,8 @@ function resolveSlideContext(presentation, index, options = {}) {
     ...options.fonts?.textMeasurement ? { textMeasurement: options.fonts.textMeasurement } : {},
     ...options.date !== void 0 ? { date: options.date } : {}
   };
-  return { options: composeOptions, diagnostics, resolved: { theme, colorScheme, fontScheme, fontSchemePath: records.fontSchemePath, ...layout ? { layout } : {}, provenance: { ...layoutProvenance ? { layout: layoutProvenance } : {}, ...records.provenance } } };
+  const resolvedSlide = resolveSlideVariables(slide, { slideNumber: composeOptions.slideNumber, slideCount: composeOptions.slideCount });
+  return { slide: resolvedSlide, options: composeOptions, diagnostics, resolved: { theme, colorScheme, fontScheme, fontSchemePath: records.fontSchemePath, ...layout ? { layout } : {}, provenance: { ...layoutProvenance ? { layout: layoutProvenance } : {}, ...records.provenance } } };
 }
 
 // src/rule-slides.ts
@@ -3188,10 +3378,17 @@ function buildSlides(document, options) {
   const slides = Array.isArray(document.slides) ? document.slides : [];
   return slides.map((slide, index) => {
     const path = pointer2("slides", index);
-    const measurement = lazy(() => measurementFor(options, index));
+    const baseContext = lazy(() => resolveSlideContext(document, index, { catalogs: options.catalogs, date: "2000-01-01" }));
+    const measurement = lazy(() => {
+      const host = measurementFor(options, index);
+      if (!host) return void 0;
+      const { resolved: resolved2 } = baseContext();
+      return slideScriptMeasurement(document, index, host, { catalogs: options.catalogs, fontFamilies: resolveFontFamilies(resolved2.fontScheme), serif: resolved2.fontScheme.type === "serif" });
+    });
     const resolved = lazy(() => {
       const textMeasurement = measurement();
-      return resolveSlideContext(document, index, { catalogs: options.catalogs, ...textMeasurement ? { fonts: { textMeasurement } } : {}, date: "2000-01-01" });
+      const slideContext = baseContext();
+      return textMeasurement ? { ...slideContext, options: { ...slideContext.options, textMeasurement } } : slideContext;
     });
     const design = lazy(() => resolveDesign(document, index, resolved()));
     const layout = lazy(() => resolved().options.layout);
@@ -3199,14 +3396,14 @@ function buildSlides(document, options) {
       const result = { layoutDiagnostics: [] };
       const compose = (input, withLayout) => composeSlide(input, { ...resolved().options, layout: withLayout });
       try {
-        result.composition = compose(slide, layout());
+        result.composition = compose(resolved().slide, layout());
         result.layoutDiagnostics.push(...result.composition.diagnostics.map((diagnostic) => ({ diagnostic, strict: false })));
       } catch (error) {
         if (error instanceof OPFCompositionError) {
           result.layoutDiagnostics.push(...error.diagnostics.map((diagnostic) => ({ diagnostic, strict: true })));
           try {
             const relaxedLayout = layout();
-            result.composition = compose(relax(slide), relaxedLayout ? relax(relaxedLayout) : void 0);
+            result.composition = compose(relax(resolved().slide), relaxedLayout ? relax(relaxedLayout) : void 0);
           } catch (second) {
             result.layoutError = second instanceof Error ? second.message : String(second);
           }
@@ -3248,12 +3445,12 @@ var OPFValidationError = class extends Error {
   report;
   /** The error-severity findings of the report. */
   findings;
-  constructor(report) {
-    const errors = report.findings.filter((entry) => entry.severity === "error");
+  constructor(report2) {
+    const errors = report2.findings.filter((entry) => entry.severity === "error");
     const first = errors[0];
     super(first ? `OPF validation failed at ${first.path || "/"}: ${first.message}` : "OPF validation failed");
     this.name = "OPFValidationError";
-    this.report = report;
+    this.report = report2;
     this.findings = errors;
   }
 };
@@ -3486,8 +3683,8 @@ function validate(input, options = {}) {
 }
 function assertValid(value, options = {}) {
   if (typeof value === "string") throw new TypeError("assertValid takes a parsed presentation. Use validate(text) for JSON text.");
-  const report = validate(value, options);
-  if (!report.valid) throw new OPFValidationError(report);
+  const report2 = validate(value, options);
+  if (!report2.valid) throw new OPFValidationError(report2);
 }
 function validateCatalogRecord(kind, value) {
   const kinds = Object.keys(catalogSchemaNames);
@@ -3508,8 +3705,8 @@ function validateCatalogRecord(kind, value) {
   return { valid: tally.error === 0, schemaValid: engine.valid, findings, counts: tally, checks };
 }
 function assertValidCatalogRecord(kind, value) {
-  const report = validateCatalogRecord(kind, value);
-  if (!report.valid) throw new OPFValidationError(report);
+  const report2 = validateCatalogRecord(kind, value);
+  if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules };
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, parseSource, resolveSlideContext, resolveSlideScriptMeasurement, validate, validateCatalogRecord, validationCategories, validationRules };

package/dist/{chunk-U4J75TRG.js → chunk-O263APNI.js}

@@ -1,4 +1,4 @@
-import { chartNumber } from './chunk-O744SXXA.js';
+import { chartNumber } from './chunk-CW7GEAV3.js';
 
 // src/data.ts
 var OPFDataImportError = class extends Error {
@@ -138,7 +138,10 @@ function importData(input, options) {
     if (circular && numeric < 0) fail(`Row ${i + 1}: pie and donut values cannot be negative.`);
     return numeric;
   }));
-  return { chart: { type: options.chartType ?? "column", data: { columns: names, rows } } };
+  return { chart: { type: options.chartType ?? "column", data: {
+    columns: names,
+    rows
+  } } };
 }
 
 export { OPFDataImportError, importData, parseTabularData };

package/dist/{chunk-UBFJ2QHH.js → chunk-O2CX5NEH.js}

@@ -1,5 +1,5 @@
-import { assertValid, resolveSlideContext } from './chunk-QDI75P2M.js';
-import { composeSlide, codeHighlightSlice, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-O744SXXA.js';
+import { assertValid, resolveSlideScriptMeasurement, resolveSlideContext } from './chunk-NLNYNBTS.js';
+import { resolveSlideVariables, usesSlideBuiltin, composeSlide, codeHighlightSlice, tableRowBoundaries, visitContentPayloads, slideTokenSpans, sliceNumberedItems } from './chunk-CW7GEAV3.js';
 import { checkCatalogsOption } from './chunk-SPFV27O5.js';
 
 // src/pagination.ts
@@ -39,6 +39,10 @@ var deckContext = (presentation) => {
   const deck = isRecord(presentation) ? presentation : {};
   return { ...Array.isArray(deck.references) ? { references: deck.references } : {}, ...isRecord(deck.datasets) ? { datasets: deck.datasets } : {} };
 };
+function keepTokensWhole(boundaries, text) {
+  const spans = slideTokenSpans(text);
+  return spans.length ? boundaries.filter((boundary) => !spans.some(([start, end]) => boundary > start && boundary < end)) : boundaries;
+}
 function leafFor(path, field, value) {
   const leaf = { path, field, value };
   let text;
@@ -62,7 +66,7 @@ function leafFor(path, field, value) {
   }
   if (text !== void 0) {
     leaf.unit = "utf16";
-    leaf.boundaries = [0, ...Array.from(graphemes.segment(text), (segment) => segment.index + segment.segment.length)];
+    leaf.boundaries = keepTokensWhole([0, ...Array.from(graphemes.segment(text), (segment) => segment.index + segment.segment.length)], text);
   } else if (field === "items" || field === "bullets") {
     leaf.unit = "items";
     leaf.boundaries = Array.from({ length: value.length + 1 }, (_, i) => i);
@@ -103,11 +107,25 @@ function paginateSlide(input, options = {}) {
   };
   source = withReadability(source);
   let evaluations = 0;
-  const { fonts, minFontSize: _minFontSize, maxSlides: _maxSlides, reservedIds: _reservedIds, ...engineOptions } = options;
-  const composeOptions = { ...engineOptions, ...fonts?.textMeasurement ? { textMeasurement: fonts.textMeasurement } : {} };
+  const { fonts, catalogs, minFontSize: _minFontSize, maxSlides: _maxSlides, reservedIds: _reservedIds, ...engineOptions } = options;
+  const textMeasurement = fonts?.textMeasurement && options.presentation !== void 0 ? resolveSlideScriptMeasurement(options.presentation, sourceIndex, fonts.textMeasurement, { ...catalogs !== void 0 ? { catalogs } : {}, ...options.fontFamilies ? { fontFamilies: options.fontFamilies } : {} }) : fonts?.textMeasurement;
+  const composeOptions = { ...engineOptions, ...textMeasurement ? { textMeasurement } : {} };
+  const readableLayout = (layout) => {
+    if (!isRecord(layout) || !Array.isArray(layout.placeholders) || !layout.placeholders.some((entry) => isRecord(entry) && entry.type === "group")) return layout;
+    const visit = (entries) => entries.map((entry) => {
+      if (!isRecord(entry) || entry.type !== "group") return entry;
+      const own = isRecord(entry.composition) ? entry.composition : {};
+      return { ...entry, composition: { ...own, ...typeof own.minFontSize === "number" ? { minFontSize: Math.max(minFontSize, own.minFontSize) } : {}, overflow: "warn" }, placeholders: Array.isArray(entry.placeholders) ? visit(entry.placeholders) : entry.placeholders };
+    });
+    return { ...layout, placeholders: visit(layout.placeholders) };
+  };
+  if (options.layout !== void 0) composeOptions.layout = readableLayout(options.layout);
+  const presentationSlides = options.presentation?.slides;
+  const slideCount = options.slideCount ?? (Array.isArray(presentationSlides) && presentationSlides.length ? presentationSlides.length : void 0);
   const geometry = (slide, pageIndex = 0) => {
     if (++evaluations > 2e4) throw new OPFPaginationError("Pagination exceeded its layout evaluation limit. Split the input into smaller sections.");
-    return composeSlide(withReadability(slide, true), { ...composeOptions, slideNumber: (options.slideNumber ?? sourceIndex + 1) + pageIndex });
+    const slideNumber = (options.slideNumber ?? sourceIndex + 1) + pageIndex;
+    return composeSlide(resolveSlideVariables(withReadability(slide, true), { slideNumber, ...slideCount !== void 0 ? { slideCount } : {} }), { ...composeOptions, slideNumber });
   };
   const initial = geometry(source);
   const fit = (diagnostics) => diagnostics.filter((issue) => issue.code === "text-overflow" || issue.code === "small-cell" || !!initial.furniture?.diagnostics.includes(issue));
@@ -123,7 +141,14 @@ function paginateSlide(input, options = {}) {
   if (!fit(initial.diagnostics).length) return { slides: [source], pages: [{ slideIndex: sourceIndex, mappings: initial.items.map((item) => ({ sourcePath: item.path, outputPath: item.path })), ...initial.furniture ? { repeatedMappings: repeatedMappings(0) } : {} }] };
   const headerIssues = initial.diagnostics.filter((issue) => headingFields.has(issue.path.slice(sourceBase.length + 1)) || initial.furniture?.diagnostics.includes(issue));
   if (headerIssues.length) throw new OPFPaginationError("Repeated headings or header/footer content cannot fit or resolve. Change the repeated content or slide design before pagination.", headerIssues);
-  const leaves = initial.items.filter((item) => !headingFields.has(item.field)).map((item) => leafFor(item.path, item.field, item.value));
+  const tokens = resolveSlideVariables(source, { slideNumber: 1, slideCount: 1 }) !== source;
+  const sourceValue = (path, fallback) => {
+    if (!tokens || !path.startsWith(`${sourceBase}.`)) return fallback;
+    let node = source;
+    for (const key of path.slice(sourceBase.length + 1).split(".")) node = isRecord(node) || Array.isArray(node) ? node[key] : void 0;
+    return node === void 0 ? fallback : node;
+  };
+  const leaves = initial.items.filter((item) => !headingFields.has(item.field)).map((item) => leafFor(item.path, item.field, sourceValue(item.path, item.value)));
   const leafPaths = new Set(leaves.map((leaf) => leaf.path));
   const slides = [], pages = [];
   let selected = /* @__PURE__ */ new Map();
@@ -246,10 +271,6 @@ function paginateSlide(input, options = {}) {
   if (!slides.length) throw new OPFPaginationError("No body content can be paginated.", initial.diagnostics);
   return { slides, pages };
 }
-var usesSlideTotal = (presentation) => [presentation, ...presentation.slides].some((owner) => ["header", "footer"].some((kind) => ["left", "center", "right"].some((zone) => {
-  const content = owner?.design?.[kind]?.[zone];
-  return content?.slideNumber === true && typeof content.slideNumberFormat === "string" && content.slideNumberFormat.includes("{total}");
-})));
 function paginate(input, options = {}) {
   checkCatalogsOption(options.catalogs, "paginate");
   assertValid(input, { only: ["format"] });
@@ -270,7 +291,7 @@ function paginate(input, options = {}) {
         }
       }
       if (output2.length >= maxSlides) throw new OPFPaginationError(`Pagination needs more than ${maxSlides} slides. No partial result was returned.`);
-      const result2 = paginateSlide(slide, { ...context.options, textRasterPadding: options.textRasterPadding, fonts: options.fonts, presentation, slideIndex: index, slideNumber: output2.length + 1, slideCount: slideCount2, date: options.date, maxSlides: maxSlides - output2.length, minFontSize: options.minFontSize, reservedIds });
+      const result2 = paginateSlide(slide, { ...context.options, textRasterPadding: options.textRasterPadding, fonts: options.fonts, ...options.catalogs ? { catalogs: options.catalogs } : {}, presentation, slideIndex: index, slideNumber: output2.length + 1, slideCount: slideCount2, date: options.date, maxSlides: maxSlides - output2.length, minFontSize: options.minFontSize, reservedIds });
       const outputStart = output2.length;
       result2.pages.forEach((page, pageIndex) => {
         const remap = (mapping) => ({ ...mapping, outputPath: mapping.outputPath.replace(/^slides\.\d+/, `slides.${outputStart + pageIndex}`) });
@@ -281,9 +302,10 @@ function paginate(input, options = {}) {
     });
     return { output: output2, pages: pages2 };
   };
+  const usesSlideCount = usesSlideBuiltin(presentation, "deck.slideCount");
   let slideCount = presentation.slides.length, result = run(slideCount);
-  for (let attempt = 0; usesSlideTotal(presentation) && result.output.length !== slideCount; attempt++) {
-    if (attempt >= 3) throw new OPFPaginationError("Slide-number totals did not converge. Change the slide-number format or split the input.");
+  for (let attempt = 0; usesSlideCount && result.output.length !== slideCount; attempt++) {
+    if (attempt >= 3) throw new OPFPaginationError("The slide count did not converge. Change the text around {{deck.slideCount}} or split the input.");
     slideCount = result.output.length;
     result = run(slideCount);
   }

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

@@ -1,4 +1,4 @@
-import { validate } from './chunk-QDI75P2M.js';
+import { validate } from './chunk-NLNYNBTS.js';
 
 // src/patch.ts
 var OPFPatchError = class extends Error {

package/dist/{chunk-VGAOJEY7.js → chunk-PPROJP2E.js}

@@ -1,4 +1,4 @@
-import { validate } from './chunk-QDI75P2M.js';
+import { validate } from './chunk-NLNYNBTS.js';
 
 // src/convert/shared.ts
 var CONTENT_KEYS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];