@openpresentation/opf 0.12.2 → 0.14.0

package/dist/index.js

@@ -1,19 +1,530 @@
-export { specFileEntries, specFileKinds, specFilePaths } from './chunk-GJKJL4YY.js';
+export { specFileEntries, specFileKinds, specFilePaths } from './chunk-D3TY4TT6.js';
 export { getLayoutPreview, hasLayoutPreview, layoutPreviewIndex, layoutPreviewSlugs, layoutPreviews } from './chunk-PIQXLBBJ.js';
-export { SYMBOL_FONT_ENCODINGS, SYMBOL_FONT_FAMILIES, isSymbolEncodedFamily, mapSymbolText, symbolCodeForUnicode, symbolCodeOf, symbolFontEncodingFor, symbolUnicodeFor } from './chunk-FYLJVF7X.js';
-export { OPFDataImportError, createDataContent, parseTabularData } from './chunk-SOSOBKQ2.js';
-export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-AUM5MXBR.js';
-export { DEFAULT_AUDIT_THRESHOLDS, DEFAULT_CHART_PALETTE, auditPresentation, auditRules, auditSource, findAuditRule } from './chunk-6LZK2IZB.js';
-export { lintPresentation, lintSource } from './chunk-MWPMJE6P.js';
-export { DEFAULT_VARIABLE_DATE_FORMAT, OPFValidationError, OPFVariableError, VARIABLE_KINDS, assertValid, assertValidCatalogRecord, assertValidPresentation, coerceVariableValue, formatVariableNumber, hasContentVariables, isTemplate, listVariables, resolveVariables, validate, validateCatalogRecord, validatePresentation, variableDeclarations } from './chunk-JKVKYVWL.js';
-import { isRecord, visitContentPayloads, bareIdPattern } from './chunk-HOBSL7AJ.js';
-export { CAPTIONABLE_FIELDS, CAPTION_FONT_RATIO, CAPTION_MAX_RATIO, CHART_SERIES_MIN_DIFFERENCE, CHART_SERIES_MIN_LIGHTNESS_STEP, CITATION_MARKER_RAISE, CITATION_MARKER_SCALE, DEFAULT_CHART_LABEL_SEPARATOR, DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, MAX_ROMAN_VALUE, NUMBERING_STYLES, NUMBERING_SUFFIXES, OPFCompositionError, PICTURE_BULLET_SCALE, annotationText, captionSettings, chartColorForFill, chartLabelText, chartOptionSupport, chartOptionTarget, chartPaletteForFill, citationMarkerText, collectCitations, colorContrast, composeSlide, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatFurnitureDate, formatListNumber, formatSlideNumber, layoutCaption, layoutCode, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, layoutTimeline, listNumbers, measureText, measureTextOutline, normalizeHexColor, numberingAtLevel, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, physicalAlignment, placeTextLines, referencesSlide, resolveCanvasDimensions, resolveChartOptions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveNumbering, resolveScriptFonts, resolveSlideDirection, resolveSocialProfile, resolveTextStyle, scriptFontRole, sliceNumberedItems, slideCitations, snapFontSizeDown, snapFontSizeUp, textColorForFill, textWidthMeasurer, walkCitationRuns, wrapText } from './chunk-HOBSL7AJ.js';
+export { OPFDataImportError, importData, parseTabularData } from './chunk-Q2TCMN56.js';
+export { fromMarkdown, toMarkdown } from './chunk-UPQQD7MA.js';
+export { OPFMarkdownError } from './chunk-4LDGKLUC.js';
+export { diff, merge } from './chunk-Z65B2B77.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch } from './chunk-BFLVSVA7.js';
+export { OPFFormatError, format } from './chunk-5ZU6JAPP.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-XIZUK2XM.js';
+import './chunk-4VJDTF55.js';
+import './chunk-CSQHPVGL.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-JDJBDYSR.js';
+import { isRecord, DEFAULT_FONT_SCHEME, visitContentPayloads, listVariables, resolveFontSchemeReference, resolveFontFamilies, resolveCanvasDimensions, bareIdPattern } from './chunk-6OXY2CP3.js';
+export { DEFAULT_VARIABLE_DATE_FORMAT, OPFVariableError, VARIABLE_KINDS, chartNumber, coerceVariableValue, datasetDiagnostics, formatDataNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, listBuiltinVariables, listVariables, normalizeLanguageFamily, numberFormatError, resolveChartData, resolveTableData, resolveVariables, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unusedDatasets, variableDeclarations } from './chunk-6OXY2CP3.js';
 import './chunk-S5W34SIJ.js';
-import { catalogEntries } from './chunk-E34DJ5LL.js';
-export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-E34DJ5LL.js';
-export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-4LAM3N6S.js';
+import { catalogs, catalogEntries } from './chunk-XOZ4KMSR.js';
+export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-XOZ4KMSR.js';
+export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-LS2FMPI5.js';
 export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-WXSPETQ6.js';
 
+// src/stats.ts
+var DEFAULT_WORDS_PER_MINUTE = 130;
+var KIND_ORDER = ["text", "items", "bullets", "quote", "metric", "code", "timeline", "chart", "table", "image", "video"];
+var FURNITURE_FIELDS = ["logo", "image", "text", "organization", "socials", "section", "slideNumber", "date"];
+var ZONES = ["left", "center", "right"];
+var LOGO_VARIANTS = ["default", "light", "dark", "stacked", "stackedLight", "stackedDark", "icon", "iconLight", "iconDark", "wordmark", "wordmarkLight", "wordmarkDark"];
+var WORD = /[\p{L}\p{N}\p{M}]+(?:['’.,-][\p{L}\p{N}\p{M}]+)*/gu;
+var UNSPACED = /[฀-໿က-႟ក-៿぀-ヿ㐀-䶿一-鿿豈-﫿]/gu;
+var wordCount = (text) => {
+  let extra = 0;
+  const spaced = text.replace(UNSPACED, () => {
+    extra++;
+    return " ";
+  });
+  return (spaced.match(WORD)?.length ?? 0) + extra;
+};
+var sorted = (values) => [...new Set(values)].sort();
+var sortedCounts = (counts) => Object.fromEntries([...counts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+var bump = (counts, key) => counts.set(key, (counts.get(key) ?? 0) + 1);
+var str = (value) => typeof value === "string" ? value : null;
+var decimals = (value, places) => Math.round(value * 10 ** places) / 10 ** places;
+var reference = (value) => {
+  if (typeof value === "string") return { id: value, inline: false };
+  if (isRecord(value)) return { id: str(value.id), inline: true };
+  return null;
+};
+var list = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+var assetForm = (src) => /^asset:/i.test(src) ? "reference" : /^data:/i.test(src) ? "embedded" : /^(https?:)?\/\//i.test(src) || /^pkg:/i.test(src) ? "remote" : "file";
+var embeddedBytes = (src) => {
+  const comma = src.indexOf(",");
+  if (comma < 0) return 0;
+  const payload = src.slice(comma + 1);
+  if (!/;base64$/i.test(src.slice(0, comma))) return payload.length;
+  const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(payload.length * 3 / 4) - padding);
+};
+var srcOf = (asset) => typeof asset === "string" ? asset : isRecord(asset) && typeof asset.src === "string" ? asset.src : void 0;
+var lookup = (deck, kind, id) => {
+  const inline = deck.catalogs?.[kind]?.records;
+  const found = (Array.isArray(inline) ? inline : []).find((record) => record?.id === id) ?? catalogs[kind].find((record) => record.id === id);
+  return isRecord(found) ? found : void 0;
+};
+var themeRecord = (deck, value) => {
+  if (typeof value === "string") return lookup(deck, "themes", value) ?? {};
+  if (isRecord(value)) return { ...typeof value.id === "string" ? lookup(deck, "themes", value.id) : void 0, ...value };
+  return {};
+};
+function slideSize(deck) {
+  const design = isRecord(deck.design) ? deck.design : {};
+  const theme2 = themeRecord(deck, design.theme ?? "minimal");
+  const source = design.dimensions !== void 0 ? "design" : theme2.dimensions !== void 0 ? "theme" : "default";
+  const dimensions = design.dimensions ?? theme2.dimensions;
+  let width = 40 / 3, height = 7.5;
+  try {
+    const resolved = resolveCanvasDimensions(dimensions);
+    width = resolved.width / 96;
+    height = resolved.height / 96;
+  } catch {
+  }
+  const preset = typeof dimensions === "string" ? dimensions : isRecord(dimensions) && typeof dimensions.preset === "string" && dimensions.widthInches === void 0 && dimensions.heightInches === void 0 ? dimensions.preset : null;
+  return { preset, widthInches: decimals(width, 4), heightInches: decimals(height, 4), aspectRatio: decimals(width / height, 3), source };
+}
+var furniture = (value) => {
+  const zones = [], fields = /* @__PURE__ */ new Set();
+  if (isRecord(value))
+    for (const zone of ZONES) {
+      const item = value[zone];
+      if (!isRecord(item)) continue;
+      const present = FURNITURE_FIELDS.filter((field) => item[field] !== void 0 && item[field] !== false);
+      if (present.length) {
+        zones.push(zone);
+        for (const field of present) fields.add(field);
+      }
+    }
+  return { configured: isRecord(value), suppressed: value === false, zones, fields: FURNITURE_FIELDS.filter((field) => fields.has(field)) };
+};
+function visitRuns(value, visit) {
+  if (typeof value === "string") visit({ text: value });
+  else if (typeof value === "number") visit({ text: String(value) });
+  else if (Array.isArray(value)) for (const entry of value) visitRuns(entry, visit);
+  else if (isRecord(value)) {
+    if (typeof value.text === "string") {
+      visit(value);
+      if (value.description !== void 0) visitRuns(value.description, visit);
+    } else if (Array.isArray(value.text)) {
+      visitRuns(value.text, visit);
+      if (value.description !== void 0) visitRuns(value.description, visit);
+    } else if (value.value !== void 0) visitRuns(value.value, visit);
+    else if (typeof value.name === "string") visit({ text: value.name });
+  }
+}
+function stats(presentation2, options = {}) {
+  if (!isRecord(presentation2)) throw new TypeError("stats needs a presentation object.");
+  const deck = presentation2;
+  const wordsPerMinute = options.wordsPerMinute ?? DEFAULT_WORDS_PER_MINUTE;
+  if (!Number.isFinite(wordsPerMinute) || wordsPerMinute <= 0) throw new RangeError("wordsPerMinute must be a positive number.");
+  const slides = Array.isArray(deck.slides) ? deck.slides.filter(isRecord) : [];
+  const design = isRecord(deck.design) ? deck.design : {};
+  const registry = isRecord(deck.assets) ? deck.assets : {};
+  const uses = { total: 0, references: 0, embedded: 0, files: 0, remote: 0 };
+  let embeddedTotal = 0;
+  const useAsset = (asset) => {
+    const src = srcOf(asset);
+    if (src === void 0) return;
+    const form = assetForm(src);
+    uses.total++;
+    uses[form === "reference" ? "references" : form === "embedded" ? "embedded" : form === "remote" ? "remote" : "files"]++;
+    if (form === "embedded") embeddedTotal += embeddedBytes(src);
+  };
+  const registryFacts = { entries: 0, embedded: 0, files: 0, remote: 0 };
+  for (const entry of Object.values(registry)) {
+    const src = srcOf(entry);
+    if (src === void 0) continue;
+    registryFacts.entries++;
+    const form = assetForm(src);
+    if (form === "embedded") {
+      registryFacts.embedded++;
+      embeddedTotal += embeddedBytes(src);
+    } else if (form === "remote") registryFacts.remote++;
+    else if (form === "file") registryFacts.files++;
+  }
+  const altOf = (asset) => {
+    if (isRecord(asset) && typeof asset.alt === "string") return asset.alt;
+    const src = srcOf(asset);
+    if (src?.startsWith("asset:")) {
+      const entry = registry[src.slice("asset:".length)];
+      if (isRecord(entry) && typeof entry.alt === "string") return entry.alt;
+    }
+    return void 0;
+  };
+  const images = { content: { total: 0, withAlt: 0, decorative: 0, missingAlt: 0 }, logos: 0, watermarks: { deck: false, slides: 0 }, backgrounds: { deck: false, slides: 0 }, headerFooter: 0, speakerPhotos: 0, videos: 0 };
+  const contentImage = (asset) => {
+    if (srcOf(asset) === void 0) return 0;
+    useAsset(asset);
+    images.content.total++;
+    const alt = altOf(asset);
+    if (alt === void 0 || alt !== "" && alt.trim() === "") images.content.missingAlt++;
+    else if (alt === "") images.content.decorative++;
+    else images.content.withAlt++;
+    return 1;
+  };
+  const logoImages = (value) => {
+    if (srcOf(value) !== void 0) {
+      useAsset(value);
+      images.logos++;
+      return;
+    }
+    if (isRecord(value)) {
+      for (const variant of LOGO_VARIANTS) if (srcOf(value[variant]) !== void 0) {
+        useAsset(value[variant]);
+        images.logos++;
+      }
+    }
+  };
+  const watermarkOf = (value) => {
+    if (value === void 0 || value === false) return false;
+    if (srcOf(value) !== void 0) useAsset(value);
+    return srcOf(value) !== void 0;
+  };
+  const backgroundImage = (value) => {
+    if (!isRecord(value) || value.type !== "image" || !isRecord(value.image)) return false;
+    useAsset(value.image);
+    return true;
+  };
+  const furnitureImages = (value) => {
+    if (!isRecord(value)) return;
+    for (const zone of ZONES) {
+      const item = value[zone];
+      if (isRecord(item) && srcOf(item.image) !== void 0) {
+        useAsset(item.image);
+        images.headerFooter++;
+      }
+    }
+  };
+  const designAssets = (value, scope) => {
+    if (!isRecord(value)) return 0;
+    logoImages(value.logo);
+    if (watermarkOf(value.watermark)) {
+      if (scope === "deck") images.watermarks.deck = true;
+      else images.watermarks.slides++;
+    }
+    if (backgroundImage(value.background)) {
+      if (scope === "deck") images.backgrounds.deck = true;
+      else images.backgrounds.slides++;
+    }
+    furnitureImages(value.header);
+    furnitureImages(value.footer);
+    return contentImage(value.slideImage);
+  };
+  const organizations = list(deck.organization).filter(isRecord).map((entry) => {
+    const hasLogo = srcOf(entry.logo) !== void 0;
+    if (hasLogo) {
+      useAsset(entry.logo);
+      images.logos++;
+    }
+    return { id: str(entry.id) ?? "", name: str(entry.name) ?? "", role: str(entry.role), hasLogo };
+  });
+  const speakers = list(deck.speaker).filter(isRecord).map((entry) => {
+    const hasPhoto = srcOf(entry.photo) !== void 0;
+    if (hasPhoto) {
+      useAsset(entry.photo);
+      images.speakerPhotos++;
+    }
+    return { id: str(entry.id) ?? "", name: str(entry.name) ?? "", title: str(entry.title), organizationId: str(entry.organizationId), hasPhoto };
+  });
+  designAssets(design, "deck");
+  for (const variable of Object.values(isRecord(deck.variables) ? deck.variables : {})) if (isRecord(variable) && variable.type === "image") useAsset(variable.value);
+  const narrative2 = reference(deck.narrative);
+  const deckFacts = {
+    name: str(deck.name),
+    description: typeof deck.description === "string" && deck.description !== "",
+    filename: str(deck.filename),
+    author: list(deck.author).filter((entry) => typeof entry === "string"),
+    language: reference(deck.language),
+    slideSize: slideSize(deck),
+    template: deck.template === true,
+    tags: Array.isArray(deck.tags) ? deck.tags.filter((tag) => typeof tag === "string") : [],
+    takeaways: list(deck.takeaway).filter((entry) => typeof entry === "string").length,
+    declaredMinutes: typeof deck.duration === "number" ? deck.duration : null,
+    design: { theme: reference(design.theme), colorScheme: reference(design.colorScheme), fontScheme: reference(design.fontScheme) },
+    audience: list(deck.audience).flatMap((entry) => reference(entry) ?? []),
+    purpose: reference(deck.purpose),
+    tone: reference(deck.tone),
+    narrative: narrative2 ? { ...narrative2, beats: isRecord(deck.narrative) && Array.isArray(deck.narrative.beats) ? deck.narrative.beats.length : 0 } : null
+  };
+  const datasetRecords = isRecord(deck.datasets) ? Object.entries(deck.datasets).filter(([, value]) => isRecord(value)) : [];
+  const datasetUse = /* @__PURE__ */ new Map();
+  const payloadCounts = { text: 0, items: 0, bullets: 0, quote: 0, metric: 0, code: 0, timeline: 0, chart: 0, table: 0, image: 0, video: 0, blocks: 0, regions: 0, groups: 0, maxDepth: 0 };
+  const layouts2 = /* @__PURE__ */ new Map(), chartTypes2 = /* @__PURE__ */ new Map(), extensions = /* @__PURE__ */ new Set();
+  const chartData = { inline: 0, dataset: 0, source: 0 };
+  const tableItems = [];
+  let tableRows = 0, tableColumns = 0, datasetBackedTables = 0, chartTotal = 0, captions = 0;
+  const hidden = [], withoutNotes = [], sections = [];
+  let withTitle = 0, withBeat = 0, unsectioned = 0, withoutLayout = 0, withOwnDesign = 0, withNotes = 0, contentWords = 0, notesWords = 0;
+  const headerOverrides = { header: 0, headerSuppressed: 0, footer: 0, footerSuppressed: 0 };
+  const total = { citations: 0, footnotes: 0, links: 0, cited: /* @__PURE__ */ new Set(), families: /* @__PURE__ */ new Set() };
+  const perSlide = [];
+  const contentPerSlide = [];
+  const schemeReferences = [];
+  const deckTheme = themeRecord(deck, design.theme ?? "minimal");
+  schemeReferences.push(design.fontScheme ?? deckTheme.fontScheme ?? DEFAULT_FONT_SCHEME);
+  slides.forEach((slide, index) => {
+    const id = str(slide.id);
+    const ref = { index, id };
+    const slideDesign = isRecord(slide.design) ? slide.design : void 0;
+    const slideTally = { words: 0, citations: 0, footnotes: 0, links: 0, cited: /* @__PURE__ */ new Set(), families: /* @__PURE__ */ new Set() };
+    const kinds = /* @__PURE__ */ new Set();
+    let slideImages = 0, slideCharts = 0, slideTables = 0;
+    const count = (text) => {
+      slideTally.words += wordCount(text);
+    };
+    const run = (value) => visitRuns(value, (entry) => {
+      count(entry.text);
+      if (typeof entry.link === "string" && entry.link !== "") slideTally.links++;
+      if (entry.cite !== void 0) {
+        slideTally.citations++;
+        for (const cite of list(entry.cite)) if (typeof cite === "string") slideTally.cited.add(cite);
+      }
+      if (entry.footnote !== void 0) slideTally.footnotes++;
+      if (typeof entry.fontFamily === "string" && entry.fontFamily !== "") slideTally.families.add(entry.fontFamily);
+    });
+    const caption = (node) => {
+      if (node.caption !== void 0) {
+        captions++;
+        run(node.caption);
+      }
+    };
+    const visitNode = (node, path, depth, kind) => {
+      if (kind === "block") payloadCounts.blocks++;
+      if (kind === "region") payloadCounts.regions++;
+      if (kind !== "root" && Array.isArray(node.blocks)) payloadCounts.groups++;
+      if (depth > payloadCounts.maxDepth) payloadCounts.maxDepth = depth;
+      for (const key of KIND_ORDER) if (node[key] !== void 0) {
+        payloadCounts[key]++;
+        kinds.add(key);
+      }
+      if (isRecord(node.extensions)) for (const key of Object.keys(node.extensions)) extensions.add(key);
+      run(node.text);
+      run(node.items);
+      run(node.bullets);
+      caption(node);
+      if (node.quote !== void 0) {
+        const quote = node.quote;
+        if (isRecord(quote)) {
+          run(quote.text);
+          run(quote.attribution);
+          run(quote.source);
+        } else run(quote);
+      }
+      if (isRecord(node.metric)) {
+        run(node.metric.value);
+        run(node.metric.label);
+        run(node.metric.description);
+        run(node.metric.unit);
+        run(node.metric.delta);
+      }
+      if (node.timeline !== void 0) {
+        const timeline = node.timeline, events = Array.isArray(timeline) ? timeline : isRecord(timeline) && Array.isArray(timeline.events) ? timeline.events : [];
+        if (isRecord(timeline)) {
+          run(timeline.name);
+          run(timeline.description);
+        }
+        for (const event of events) if (isRecord(event)) {
+          run(event.when);
+          run(event.what);
+          run(event.description);
+        }
+      }
+      if (node.image !== void 0) slideImages += contentImage(node.image);
+      if (node.video !== void 0) {
+        useAsset(node.video);
+        images.videos++;
+      }
+      if (isRecord(node.chart)) {
+        chartTotal++;
+        slideCharts++;
+        bump(chartTypes2, str(node.chart.type) ?? "unknown");
+        const data = node.chart.data;
+        if (isRecord(data)) {
+          if (typeof data.dataset === "string") {
+            chartData.dataset++;
+            bump(datasetUse, data.dataset);
+          } else if (Array.isArray(data.columns) || Array.isArray(data.rows)) chartData.inline++;
+          else if (typeof data.src === "string") {
+            chartData.source++;
+            useAsset(data.src);
+          }
+        }
+      }
+      if (isRecord(node.table)) {
+        slideTables++;
+        const table = node.table;
+        let rows = 0, columns = 0, dataset = null;
+        if (typeof table.dataset === "string") {
+          dataset = table.dataset;
+          datasetBackedTables++;
+          bump(datasetUse, dataset);
+          const source = isRecord(deck.datasets) && isRecord(deck.datasets[dataset]) ? deck.datasets[dataset] : void 0;
+          rows = Array.isArray(source?.rows) ? source.rows.length : 0;
+          columns = Array.isArray(table.fields) ? table.fields.length : Array.isArray(source?.columns) ? source.columns.length : 0;
+        } else {
+          const body = Array.isArray(table.rows) ? table.rows : [];
+          rows = body.length;
+          columns = Array.isArray(table.columns) ? table.columns.length : body.reduce((widest, row) => Math.max(widest, Array.isArray(row) ? row.length : 0), 0);
+          run(table.columns);
+          for (const row of body) run(row);
+        }
+        tableRows += rows;
+        tableColumns += columns;
+        tableItems.push({ slide: index, path: `${path}/table`, rows, columns, dataset });
+      }
+    };
+    run(slide.title);
+    run(slide.subtitle);
+    run(slide.tag);
+    const slidePath = `/slides/${index}`;
+    visitNode(slide, slidePath, 0, "root");
+    visitContentPayloads(slide, slidePath, (node, path) => {
+      const relative = path.slice(slidePath.length + 1);
+      visitNode(node, path, (relative.match(/(^|\/)blocks\//g) ?? []).length, /(^|\/)blocks\/\d+$/.test(relative) ? "block" : "region");
+    });
+    const notes = typeof slide.notes === "string" ? slide.notes : "";
+    const noteWords = wordCount(notes);
+    const hasNotes = notes.trim() !== "";
+    if (hasNotes) withNotes++;
+    else withoutNotes.push(ref);
+    notesWords += noteWords;
+    contentWords += slideTally.words;
+    contentPerSlide.push(slideTally.words);
+    total.citations += slideTally.citations;
+    total.footnotes += slideTally.footnotes;
+    total.links += slideTally.links;
+    for (const cite of slideTally.cited) total.cited.add(cite);
+    for (const family of slideTally.families) total.families.add(family);
+    const title = typeof slide.title === "string" && slide.title.trim() !== "" ? slide.title : null;
+    if (title) withTitle++;
+    if (slide.beat !== void 0) withBeat++;
+    if (slide.hidden === true) hidden.push(ref);
+    const layout2 = str(slide.layout);
+    if (layout2) bump(layouts2, layout2);
+    else withoutLayout++;
+    const section = str(slide.section);
+    if (section !== null && section !== "") {
+      const last = sections.at(-1);
+      if (last && last.name === section && last.firstSlide + last.slides === index) last.slides++;
+      else sections.push({ name: section, slides: 1, firstSlide: index });
+    } else unsectioned++;
+    if (slideDesign) {
+      withOwnDesign++;
+      slideImages += designAssets(slideDesign, "slide");
+      for (const kind of ["header", "footer"]) {
+        if (slideDesign[kind] === false) headerOverrides[`${kind}Suppressed`]++;
+        else if (isRecord(slideDesign[kind])) headerOverrides[kind]++;
+      }
+      if (slideDesign.fontScheme !== void 0) schemeReferences.push(slideDesign.fontScheme);
+      else if (slideDesign.theme !== void 0 && design.fontScheme === void 0) schemeReferences.push(themeRecord(deck, slideDesign.theme).fontScheme ?? DEFAULT_FONT_SCHEME);
+    }
+    if (options.perSlide)
+      perSlide.push({
+        index,
+        id,
+        title,
+        layout: layout2,
+        section: section === "" ? null : section,
+        hidden: slide.hidden === true,
+        payloads: KIND_ORDER.filter((kind) => kinds.has(kind)),
+        words: { content: slideTally.words, notes: noteWords },
+        hasNotes,
+        speakingSeconds: Math.round(noteWords / wordsPerMinute * 60),
+        images: slideImages,
+        charts: slideCharts,
+        tables: slideTables,
+        citations: slideTally.citations
+      });
+  });
+  if (isRecord(deck.extensions)) for (const key of Object.keys(deck.extensions)) extensions.add(key);
+  const datasetItems = datasetRecords.map(([id, value]) => ({
+    id,
+    title: str(value.title),
+    columns: Array.isArray(value.columns) ? value.columns.length : 0,
+    rows: Array.isArray(value.rows) ? value.rows.length : 0,
+    source: isRecord(value.source) ? str(value.source.src) : null,
+    referencedBy: datasetUse.get(id) ?? 0
+  }));
+  const references = Array.isArray(deck.references) ? deck.references.filter(isRecord) : [];
+  const referenceIds = references.map((entry) => str(entry.id)).filter((entry) => entry !== null);
+  const cited = referenceIds.filter((entry) => total.cited.has(entry));
+  const variables = listVariables(deck, isRecord(options.values) ? options.values : {});
+  const byKind = /* @__PURE__ */ new Map();
+  for (const variable of variables) bump(byKind, variable.kind);
+  const variableFacts = {
+    declared: variables.length,
+    byKind: sortedCounts(byKind),
+    required: variables.filter((variable) => variable.required).length,
+    optional: variables.filter((variable) => !variable.required).length,
+    filled: variables.filter((variable) => variable.filled).length,
+    unfilled: variables.filter((variable) => !variable.filled).map((variable) => variable.id),
+    unfilledRequired: variables.filter((variable) => !variable.filled && variable.required).map((variable) => variable.id),
+    unused: variables.filter((variable) => variable.uses.length === 0).map((variable) => variable.id)
+  };
+  const families = new Set(total.families), schemeIds = /* @__PURE__ */ new Set(), unresolved = /* @__PURE__ */ new Set();
+  const addScheme = (value) => {
+    const resolved = resolveFontSchemeReference(value, (id2) => lookup(deck, "fontSchemes", id2));
+    if (resolved.diagnostic) unresolved.add(resolved.diagnostic.id);
+    const id = typeof value === "string" ? value : isRecord(value) && typeof value.id === "string" ? value.id : void 0;
+    if (id !== void 0) schemeIds.add(id);
+    const scheme = resolved.scheme;
+    const named = resolveFontFamilies(scheme);
+    families.add(named.heading);
+    families.add(named.body);
+    if (scheme.code !== void 0) families.add(named.code);
+    if (named.accent) families.add(named.accent);
+  };
+  for (const entry of schemeReferences) addScheme(entry);
+  const catalogOverrides = {};
+  if (isRecord(deck.catalogs))
+    for (const kind of Object.keys(deck.catalogs).sort()) {
+      const entry = deck.catalogs[kind];
+      if (isRecord(entry)) catalogOverrides[kind] = { records: Array.isArray(entry.records) ? entry.records.length : 0, source: str(entry.source) };
+    }
+  const colorVariables = variables.filter((variable) => variable.kind === "color").map((variable) => ({ id: variable.id, value: typeof variable.value === "string" ? variable.value : null, uses: variable.uses.length }));
+  const contentMean = slides.length ? decimals(contentWords / slides.length, 1) : 0;
+  const result = {
+    deck: deckFacts,
+    people: { organizations, speakers },
+    slides: {
+      total: slides.length,
+      hidden,
+      withTitle,
+      withoutTitle: slides.length - withTitle,
+      withBeat,
+      sections,
+      unsectioned,
+      layouts: sortedCounts(layouts2),
+      withoutLayout,
+      withOwnDesign
+    },
+    payloads: payloadCounts,
+    words: {
+      content: contentWords,
+      notes: notesWords,
+      total: contentWords + notesWords,
+      perSlide: { min: contentPerSlide.length ? Math.min(...contentPerSlide) : 0, max: contentPerSlide.length ? Math.max(...contentPerSlide) : 0, mean: contentMean }
+    },
+    notes: { withNotes, withoutNotes },
+    speakingTime: { basis: "estimate", wordsPerMinute, notesWords, minutes: decimals(notesWords / wordsPerMinute, 1), declaredMinutes: deckFacts.declaredMinutes },
+    images,
+    charts: { total: chartTotal, byType: sortedCounts(chartTypes2), data: chartData },
+    tables: { total: tableItems.length, datasetBacked: datasetBackedTables, rows: tableRows, columns: tableColumns, items: tableItems },
+    datasets: { count: datasetItems.length, withSource: datasetItems.filter((item) => item.source !== null).length, items: datasetItems },
+    citations: { references: references.length, cited, citations: total.citations, footnotes: total.footnotes, captions, links: total.links },
+    variables: variableFacts,
+    assets: { registry: registryFacts, uses, embeddedBytes: embeddedTotal },
+    headerFooter: {
+      header: furniture(design.header),
+      footer: furniture(design.footer),
+      slides: { headerOverrides: headerOverrides.header, headerSuppressed: headerOverrides.headerSuppressed, footerOverrides: headerOverrides.footer, footerSuppressed: headerOverrides.footerSuppressed }
+    },
+    fonts: { families: sorted(families), schemeIds: sorted(schemeIds), unresolvedSchemeIds: sorted(unresolved), runOverrides: sorted(total.families) },
+    colors: { variables: colorVariables },
+    extensions: sorted(extensions),
+    catalogOverrides
+  };
+  if (options.perSlide) result.perSlide = perSlide;
+  return result;
+}
+
 // src/bundle.ts
 function reportKey(kind, id) {
   return `${kind}:${id}`;
@@ -60,7 +571,7 @@ function collectSocialReferences(collector, holder) {
 function collectBeatReferences(collector, narrative2) {
   if (!isRecord(narrative2) || !Array.isArray(narrative2.beats)) return;
   for (const beat of narrative2.beats) {
-    if (isRecord(beat)) addReference(collector, "layouts", beat.layoutHint, false);
+    if (isRecord(beat)) addReference(collector, "layouts", beat.layout, false);
   }
 }
 function collectLanguageReferences(collector, language2) {
@@ -71,12 +582,13 @@ function collectLanguageReferences(collector, language2) {
 }
 function collectDocumentReferences(collector, document) {
   addReference(collector, "narratives", document.narrative, typeof document.narrative === "string");
-  collectBeatReferences(collector, document.narrative);
   addReference(collector, "tones", document.tone, false);
   addReference(collector, "purposes", document.purpose, false);
   collectLanguageReferences(collector, document.language);
   if (Array.isArray(document.audience)) {
     for (const entry of document.audience) addReference(collector, "audiences", entry, true);
+  } else if (isRecord(document.audience)) {
+    addReference(collector, "audiences", document.audience, true);
   } else {
     addReference(collector, "audiences", document.audience, typeof document.audience === "string");
   }
@@ -146,11 +658,11 @@ function kindState(states, catalogsField, kind) {
   return state;
 }
 function pushReportId(map, kind, id) {
-  const list = map[kind];
-  if (list) list.push(id);
+  const list2 = map[kind];
+  if (list2) list2.push(id);
   else map[kind] = [id];
 }
-function bundlePresentation(value) {
+function bundle(value) {
   const report = { added: {}, alreadyInline: {}, keptSources: [], unresolved: {} };
   if (!isRecord(value)) {
     return { presentation: value, report };
@@ -211,929 +723,4 @@ function bundlePresentation(value) {
   return { presentation: presentation2, report };
 }
 
-// src/legible-color.ts
-var channels = (hex) => [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
-var toHex = (values) => `#${values.map((value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
-var linear = (value) => {
-  const n = value / 255;
-  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
-};
-var luminance = (hex) => {
-  const [r, g, b] = channels(hex);
-  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
-};
-var contrast = (a, b) => {
-  const x = luminance(a), y = luminance(b);
-  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
-};
-var normalize = (value) => {
-  if (typeof value !== "string") return void 0;
-  const text = value.trim();
-  if (/^#[0-9a-f]{3}$/i.test(text)) return `#${[...text.slice(1)].map((c) => c + c).join("")}`.toUpperCase();
-  return /^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(text) ? text.slice(0, 7).toUpperCase() : void 0;
-};
-function toHsl(hex) {
-  const [r, g, b] = channels(hex).map((value) => value / 255);
-  const max = Math.max(r, g, b), min = Math.min(r, g, b), l = (max + min) / 2, d = max - min;
-  if (d === 0) return [0, 0, l];
-  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-  const h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
-  return [h * 60, s, l];
-}
-function fromHsl(h, s, l) {
-  const hue = (h % 360 + 360) % 360, c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(hue / 60 % 2 - 1)), m = l - c / 2;
-  const [r, g, b] = hue < 60 ? [c, x, 0] : hue < 120 ? [x, c, 0] : hue < 180 ? [0, c, x] : hue < 240 ? [0, x, c] : hue < 300 ? [x, 0, c] : [c, 0, x];
-  return toHex([(r + m) * 255, (g + m) * 255, (b + m) * 255]);
-}
-function legible(foreground, background, minimum) {
-  if (contrast(foreground, background) >= minimum) return foreground;
-  const [h, s, l] = toHsl(foreground), preferred = luminance(background) < 0.5 ? 1 : -1;
-  for (const direction of [preferred, -preferred]) {
-    for (let step = 1; step <= 100; step++) {
-      const lightness = l + direction * step / 100;
-      if (lightness < 0 || lightness > 1) break;
-      const candidate = fromHsl(h, s, lightness);
-      if (contrast(candidate, background) >= minimum) return candidate;
-    }
-  }
-  return contrast("#FFFFFF", background) >= contrast("#000000", background) ? "#FFFFFF" : "#000000";
-}
-
-// src/code-syntax.ts
-var CODE_HIGHLIGHT_MAX_LENGTH = 2e5;
-var CODE_SYNTAX_MIN_CONTRAST = 4.5;
-var CODE_PANEL_BACKGROUND = "#111827";
-var CODE_PANEL_FOREGROUND = "#E5E7EB";
-var set = (words) => new Set((words ?? "").split(/\s+/).filter(Boolean));
-var JS_KEYWORDS = "break case catch class const continue debugger default delete do else enum export extends finally for from function if import in instanceof let new of return static super switch this throw try typeof var void while with yield async await as get set declare namespace module abstract implements interface private protected public readonly override keyof satisfies type is infer";
-var JS = { line: ["//"], block: [["/*", "*/"]], strings: "'\"`", keywords: JS_KEYWORDS, literals: "true false null undefined NaN Infinity", types: "string number boolean object symbol bigint never unknown any void", defs: { function: "function", class: "type", interface: "type", enum: "type", type: "type" }, capsTypes: true, calls: true, decorators: true };
-var C_LIKE_KEYWORDS = "auto break case catch char class const constexpr continue default delete do double else enum explicit extern false final float for friend goto if inline int long mutable namespace new noexcept nullptr operator override private protected public register return short signed sizeof static struct switch template this throw true try typedef typename union unsigned using virtual void volatile while";
-var LANGUAGES = {
-  javascript: JS,
-  typescript: JS,
-  python: { line: ["#"], strings: `'"`, triple: ['"""', "'''"], keywords: "and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield match case self cls", literals: "True False None", types: "int float str bool bytes list dict set tuple object type", defs: { def: "function", class: "type" }, capsTypes: true, calls: true, decorators: true },
-  rust: { line: ["//"], block: [["/*", "*/"]], strings: '"', rawStrings: "r", keywords: "as async await break const continue crate dyn else enum extern fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait type unsafe use where while", literals: "true false", types: "i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 bool char str String Vec Option Result Box", defs: { fn: "function", struct: "type", enum: "type", trait: "type", type: "type", mod: "type" }, capsTypes: true, calls: true, macros: true },
-  go: { line: ["//"], block: [["/*", "*/"]], strings: "\"'`", noEscapes: "`", keywords: "break case chan const continue default defer else fallthrough for func go goto if import interface map package range return select struct switch type var", literals: "true false nil iota", types: "int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex64 complex128 string bool byte rune error any", defs: { func: "function", type: "type" }, capsTypes: true, calls: true },
-  bash: { line: ["#"], strings: `'"`, noEscapes: "'", keywords: "if then else elif fi for while until do done case esac in function select time return exit break continue export local readonly declare unset set shift source alias trap eval exec", literals: "true false", variables: true, calls: false },
-  json: { line: ["//"], block: [["/*", "*/"]], strings: '"', literals: "true false null", quotedKeys: true },
-  yaml: { kind: "yaml" },
-  toml: { kind: "ini", line: ["#"] },
-  ini: { kind: "ini", line: ["#", ";"] },
-  markup: { kind: "markup" },
-  css: { kind: "css" },
-  sql: { line: ["--"], block: [["/*", "*/"]], strings: `'"`, ci: true, keywords: "add all alter and any as asc between by case check column commit constraint create cross database default delete desc distinct drop else end exists foreign from full group having if in index inner insert into is join key left like limit not null offset on or order outer primary references replace right rollback select set table then top union unique update values view when where with", literals: "true false", types: "int integer bigint smallint decimal numeric float real double varchar char text date time timestamp boolean serial uuid json" },
-  java: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract assert break case catch class const continue default do else enum extends final finally for goto if implements import instanceof interface native new package private protected public return static strictfp super switch synchronized this throw throws transient try var volatile while record sealed permits", literals: "true false null", types: "boolean byte char double float int long short void String Object", defs: { class: "type", interface: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: true },
-  csharp: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract as async await base break case catch checked class const continue default delegate do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace new operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw try typeof unchecked unsafe using var virtual volatile while record init required", literals: "true false null", types: "bool byte char decimal double float int long object sbyte short string uint ulong ushort void dynamic", defs: { class: "type", interface: "type", struct: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: false },
-  kotlin: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, triple: ['"""'], keywords: "abstract actual annotation as break by catch class companion const constructor continue crossinline data do else enum expect external final finally for fun get if import in infix init inline inner interface internal is it lateinit lazy noinline object open operator out override package private protected public reified return sealed set super suspend tailrec this throw try typealias val var vararg when where while", literals: "true false null", types: "Int Long Short Byte Float Double Boolean Char String Unit Any Nothing", defs: { fun: "function", class: "type", interface: "type", object: "type" }, capsTypes: true, calls: true, decorators: true },
-  swift: { line: ["//"], block: [["/*", "*/"]], strings: '"', triple: ['"""'], keywords: "actor as associatedtype async await break case catch class continue default defer deinit do else enum extension fallthrough fileprivate for func guard if import in init inout internal is let nonisolated open operator private protocol public repeat rethrows return self Self static struct subscript super switch throw throws try typealias var where while", literals: "true false nil", types: "Int Double Float Bool String Character Array Dictionary Set Optional Any", defs: { func: "function", class: "type", struct: "type", enum: "type", protocol: "type", extension: "type" }, capsTypes: true, calls: true, decorators: true },
-  ruby: { line: ["#"], strings: `'"`, keywords: "alias and begin break case class def defined do else elsif end ensure for if in module next not or redo rescue retry return self super then undef unless until when while yield require require_relative include extend attr_accessor attr_reader attr_writer private protected public", literals: "true false nil", defs: { def: "function", class: "type", module: "type" }, capsTypes: true, calls: true },
-  php: { line: ["//", "#"], block: [["/*", "*/"]], strings: `'"`, keywords: "abstract and array as break callable case catch class clone const continue declare default do echo else elseif empty enddeclare endfor endforeach endif endswitch endwhile extends final finally fn for foreach function global goto if implements include include_once instanceof insteadof interface isset list match namespace new or print private protected public readonly require require_once return static switch throw trait try unset use var while xor yield", literals: "true false null TRUE FALSE NULL", defs: { function: "function", class: "type", interface: "type", trait: "type" }, capsTypes: true, calls: true, variables: true },
-  c: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: C_LIKE_KEYWORDS, literals: "true false NULL nullptr", types: "size_t ssize_t int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t bool FILE", calls: true, capsTypes: false, directives: true, defs: { struct: "type", enum: "type", union: "type", class: "type" } },
-  hcl: { line: ["#", "//"], block: [["/*", "*/"]], strings: '"', keywords: "resource data variable output locals module provider terraform for in if else dynamic content backend required_providers lifecycle", literals: "true false null", types: "string number bool list map set object tuple any", calls: true },
-  dockerfile: { line: ["#"], strings: `'"`, keywords: "FROM RUN CMD LABEL MAINTAINER EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG ONBUILD STOPSIGNAL HEALTHCHECK SHELL AS", variables: true }
-};
-var ALIASES = {
-  js: "javascript",
-  javascript: "javascript",
-  mjs: "javascript",
-  cjs: "javascript",
-  jsx: "javascript",
-  node: "javascript",
-  nodejs: "javascript",
-  ts: "typescript",
-  typescript: "typescript",
-  tsx: "typescript",
-  mts: "typescript",
-  cts: "typescript",
-  python: "python",
-  py: "python",
-  python3: "python",
-  py3: "python",
-  rust: "rust",
-  rs: "rust",
-  go: "go",
-  golang: "go",
-  bash: "bash",
-  sh: "bash",
-  shell: "bash",
-  zsh: "bash",
-  console: "bash",
-  shellscript: "bash",
-  fish: "bash",
-  json: "json",
-  jsonc: "json",
-  json5: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  toml: "toml",
-  ini: "ini",
-  conf: "ini",
-  cfg: "ini",
-  properties: "ini",
-  env: "ini",
-  markup: "markup",
-  html: "markup",
-  xml: "markup",
-  svg: "markup",
-  xhtml: "markup",
-  vue: "markup",
-  plist: "markup",
-  css: "css",
-  scss: "css",
-  less: "css",
-  sass: "css",
-  sql: "sql",
-  postgres: "sql",
-  postgresql: "sql",
-  mysql: "sql",
-  sqlite: "sql",
-  pgsql: "sql",
-  java: "java",
-  csharp: "csharp",
-  cs: "csharp",
-  "c#": "csharp",
-  kotlin: "kotlin",
-  kt: "kotlin",
-  swift: "swift",
-  ruby: "ruby",
-  rb: "ruby",
-  php: "php",
-  c: "c",
-  h: "c",
-  cpp: "c",
-  "c++": "c",
-  cc: "c",
-  cxx: "c",
-  hpp: "c",
-  hh: "c",
-  objc: "c",
-  hcl: "hcl",
-  terraform: "hcl",
-  tf: "hcl",
-  tfvars: "hcl",
-  dockerfile: "dockerfile",
-  docker: "dockerfile"
-};
-var CODE_HIGHLIGHT_LANGUAGES = Object.freeze(Object.keys(LANGUAGES));
-function resolveCodeLanguage(language2) {
-  if (typeof language2 !== "string") return void 0;
-  const key = language2.trim().toLowerCase().replace(/^(?:language|lang)[-:]/, "").replace(/^\./, "");
-  return Object.hasOwn(ALIASES, key) ? ALIASES[key] : void 0;
-}
-var IDENT = /[\p{L}_$][\p{L}\p{N}_$]*/uy;
-var NUMBER = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)[a-zA-Z]{0,4}/y;
-var isIdentChar = (character) => character !== void 0 && /[\p{L}\p{N}_$]/u.test(character);
-function endOfLine(source, from) {
-  const index = source.slice(from).search(/\r\n|\r|\n/);
-  return index < 0 ? source.length : from + index;
-}
-function pushToken(tokens, start, end, kind) {
-  if (end <= start) return;
-  const last = tokens[tokens.length - 1];
-  if (last && last.kind === kind && last.end === start && kind !== "function" && kind !== "property") last.end = end;
-  else tokens.push({ start, end, kind });
-}
-function scanQuoted(source, from, quote, escapes, multiline) {
-  let index = from + 1;
-  while (index < source.length) {
-    const character = source[index];
-    if (escapes && character === "\\") {
-      index += 2;
-      continue;
-    }
-    if (character === quote) return index + 1;
-    if (!multiline && (character === "\n" || character === "\r")) return index;
-    index++;
-  }
-  return source.length;
-}
-function scanGeneric(source, def) {
-  const tokens = [];
-  const keywords = set(def.keywords), literals = set(def.literals), types = set(def.types);
-  const fold = (word) => def.ci ? word.toLowerCase() : word;
-  if (def.ci) for (const list of [keywords, literals, types]) for (const word of [...list]) {
-    list.delete(word);
-    list.add(word.toLowerCase());
-  }
-  const strings = def.strings ?? "", lineComments = def.line ?? [], blocks = def.block ?? [], triples = def.triple ?? [];
-  let index = 0, pendingDef;
-  const atLineStart = (position) => {
-    let at = position - 1;
-    while (at >= 0 && (source[at] === " " || source[at] === "	")) at--;
-    return at < 0 || source[at] === "\n" || source[at] === "\r";
-  };
-  while (index < source.length) {
-    const character = source[index];
-    if (/\s/.test(character)) {
-      index++;
-      continue;
-    }
-    const lineComment = lineComments.find((opener) => source.startsWith(opener, index));
-    if (lineComment && !(lineComment === "#" && def.directives) && !(lineComment === "#" && def.variables && source[index - 1] === "$") && !(def.variables && lineComment === "#" && index > 0 && !/[\s;&|(]/.test(source[index - 1]))) {
-      const end = endOfLine(source, index);
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
-    }
-    const block = blocks.find(([opener]) => source.startsWith(opener, index));
-    if (block) {
-      const close = source.indexOf(block[1], index + block[0].length);
-      const end = close < 0 ? source.length : close + block[1].length;
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
-    }
-    if (def.directives && character === "#" && atLineStart(index)) {
-      const match = /#[ \t]*\w+/y;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "keyword");
-        index += found[0].length;
-        if (/include/.test(found[0])) {
-          const header = /[ \t]*(<[^>\n]*>)/y;
-          header.lastIndex = index;
-          const matched = header.exec(source);
-          if (matched) {
-            const start = index + matched[0].length - matched[1].length;
-            pushToken(tokens, start, start + matched[1].length, "string");
-            index += matched[0].length;
-          }
-        }
-        continue;
-      }
-    }
-    const triple = triples.find((opener) => source.startsWith(opener, index));
-    if (triple) {
-      const close = source.indexOf(triple, index + 3);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, index, end, "string");
-      index = end;
-      pendingDef = void 0;
-      continue;
-    }
-    if (def.rawStrings && character === def.rawStrings && /^r#*"/.test(source.slice(index, index + 8)) && !isIdentChar(source[index - 1])) {
-      const hashes = /^r(#*)"/.exec(source.slice(index, index + 8))[1];
-      const close = source.indexOf(`"${hashes}`, index + 2 + hashes.length);
-      const end = close < 0 ? source.length : close + 1 + hashes.length;
-      pushToken(tokens, index, end, "string");
-      index = end;
-      continue;
-    }
-    if (strings.includes(character)) {
-      if (def === LANGUAGES.rust && character === "'" && !/^'(?:\\.[^']*|[^\\'])'/.test(source.slice(index, index + 12))) {
-        const match = /'[\p{L}_][\p{L}\p{N}_]*/uy;
-        match.lastIndex = index;
-        const found = match.exec(source);
-        const end2 = index + (found ? found[0].length : 1);
-        if (found) pushToken(tokens, index, end2, "type");
-        index = end2;
-        continue;
-      }
-      const escapes = !(def.noEscapes ?? "").includes(character);
-      const multiline = character === "`";
-      const end = scanQuoted(source, index, character, escapes, multiline);
-      let kind = "string";
-      if (def.quotedKeys) {
-        const after = /^[ \t]*:/.exec(source.slice(end, end + 40));
-        if (after) kind = "property";
-      }
-      pushToken(tokens, index, end, kind);
-      index = end;
-      pendingDef = void 0;
-      continue;
-    }
-    if (def.variables && character === "$") {
-      const match = /\$(?:\{[^}\n]*\}|[A-Za-z_]\w*|[0-9@#?!$*-])/y;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "property");
-        index += found[0].length;
-        continue;
-      }
-    }
-    if (def.decorators && character === "@" && /[\p{L}_]/u.test(source[index + 1] ?? "")) {
-      const match = /@[\p{L}_][\p{L}\p{N}_$.]*/uy;
-      match.lastIndex = index;
-      const found = match.exec(source);
-      pushToken(tokens, index, index + found[0].length, "function");
-      index += found[0].length;
-      continue;
-    }
-    if (/\d/.test(character) && !isIdentChar(source[index - 1])) {
-      NUMBER.lastIndex = index;
-      const found = NUMBER.exec(source);
-      if (found) {
-        pushToken(tokens, index, index + found[0].length, "number");
-        index += found[0].length;
-        pendingDef = void 0;
-        continue;
-      }
-    }
-    if (def === LANGUAGES.python && /[rRbBfFuU]/.test(character) && /^[rRbBfFuU]{1,2}['"]/.test(source.slice(index, index + 3)) && !isIdentChar(source[index - 1])) {
-      const prefix = /^[rRbBfFuU]{1,2}/.exec(source.slice(index, index + 3))[0].length;
-      const quote = source[index + prefix];
-      const triple2 = source.startsWith(quote.repeat(3), index + prefix);
-      let end;
-      if (triple2) {
-        const close = source.indexOf(quote.repeat(3), index + prefix + 3);
-        end = close < 0 ? source.length : close + 3;
-      } else end = scanQuoted(source, index + prefix, quote, !/[rR]/.test(source.slice(index, index + prefix)), false);
-      pushToken(tokens, index, end, "string");
-      index = end;
-      pendingDef = void 0;
-      continue;
-    }
-    IDENT.lastIndex = index;
-    const identifier = IDENT.exec(source);
-    if (identifier) {
-      const word = identifier[0], end = index + word.length, folded = fold(word);
-      let kind;
-      if (pendingDef && !keywords.has(folded)) kind = pendingDef;
-      else if (keywords.has(folded)) {
-        kind = "keyword";
-        pendingDef = def.defs && Object.hasOwn(def.defs, folded) ? def.defs[folded] : void 0;
-        pushToken(tokens, index, end, kind);
-        index = end;
-        continue;
-      } else if (literals.has(word) || literals.has(folded)) kind = "number";
-      else if (types.has(folded)) kind = "type";
-      else if (def.calls && source[end] === "(") kind = "function";
-      else if (def.macros && source[end] === "!" && /[([{]/.test(source[end + 1] ?? "")) kind = "function";
-      else if (def.capsTypes && /^[A-Z]/.test(word) && /[a-z]/.test(word)) kind = "type";
-      pendingDef = void 0;
-      if (kind) pushToken(tokens, index, end, kind);
-      index = end;
-      continue;
-    }
-    pendingDef = void 0;
-    index++;
-  }
-  return tokens;
-}
-var YAML_LITERALS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off", "~", "True", "False", "Null", "TRUE", "FALSE", "NULL"]);
-function scanYamlValue(source, start, end, tokens, comments) {
-  let index = start;
-  while (index < end) {
-    const character = source[index];
-    if (character === "#" && (index === start || /\s/.test(source[index - 1])) && comments.includes("#")) {
-      pushToken(tokens, index, end, "comment");
-      return;
-    }
-    if (character === ";" && comments.includes(";") && (index === start || /\s/.test(source[index - 1]))) {
-      pushToken(tokens, index, end, "comment");
-      return;
-    }
-    if (character === '"' || character === "'") {
-      const close = scanQuoted(source, index, character, character === '"', false);
-      pushToken(tokens, index, Math.min(close, end), "string");
-      index = Math.min(close, end);
-      continue;
-    }
-    if ((character === "&" || character === "*") && /[\w-]/.test(source[index + 1] ?? "")) {
-      const match = /[&*][\w-]+/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      pushToken(tokens, index, index + found2[0].length, "type");
-      index += found2[0].length;
-      continue;
-    }
-    if (!isIdentChar(source[index - 1]) && /[\d-]/.test(character)) {
-      const match = /-?\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?(?=[\s,\]}]|$)/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2 && index + found2[0].length <= end) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
-      }
-    }
-    const word = /[\w.~-]+/y;
-    word.lastIndex = index;
-    const found = word.exec(source);
-    if (found) {
-      if (YAML_LITERALS.has(found[0]) && !/[\w.-]/.test(source[index + found[0].length] ?? "")) pushToken(tokens, index, index + found[0].length, "number");
-      index += found[0].length;
-      continue;
-    }
-    index++;
-  }
-}
-function lineRanges(source) {
-  const ranges = [];
-  let cursor = 0;
-  const pattern = /\r\n|\r|\n/g;
-  for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
-    ranges.push({ start: cursor, end: match.index });
-    cursor = match.index + match[0].length;
-  }
-  ranges.push({ start: cursor, end: source.length });
-  return ranges;
-}
-function yamlKey(source, from, to) {
-  const first = source[from];
-  if (first === void 0 || from >= to) return void 0;
-  let index = from;
-  if (first === '"' || first === "'") {
-    index = Math.min(scanQuoted(source, from, first, first === '"', false), to);
-    let at = index;
-    while (at < to && (source[at] === " " || source[at] === "	")) at++;
-    return source[index - 1] === first && source[at] === ":" && (at + 1 >= to || /\s/.test(source[at + 1])) ? { nameEnd: index, colon: at } : void 0;
-  }
-  if (/[\s#:{}[\],&*!|>%@`]/.test(first) || first === "-" && /[\s#:]/.test(source[from + 1] ?? " ")) return void 0;
-  for (; index < to; index++) {
-    const character = source[index];
-    if (character === "#" && /\s/.test(source[index - 1])) return void 0;
-    if (character === ":" && (index + 1 >= to || /\s/.test(source[index + 1]))) {
-      let nameEnd = index;
-      while (nameEnd > from && /\s/.test(source[nameEnd - 1])) nameEnd--;
-      return nameEnd > from ? { nameEnd, colon: index } : void 0;
-    }
-  }
-  return void 0;
-}
-function scanYaml(source) {
-  const tokens = [];
-  let blockIndent = -1;
-  for (const { start, end } of lineRanges(source)) {
-    const text = source.slice(start, end), indent = /^ */.exec(text)[0].length;
-    if (blockIndent >= 0) {
-      if (text.trim() === "" || indent > blockIndent) {
-        if (text.trim() !== "") pushToken(tokens, start + indent, end, "string");
-        continue;
-      }
-      blockIndent = -1;
-    }
-    if (/^\s*#/.test(text)) {
-      pushToken(tokens, start + indent, end, "comment");
-      continue;
-    }
-    if (/^(?:---|\.\.\.)(?:\s|$)/.test(text)) {
-      pushToken(tokens, start, start + 3, "keyword");
-      scanYamlValue(source, start + 3, end, tokens, "#");
-      continue;
-    }
-    let cursor = start + indent;
-    const dash = /^(?:-\s+)+/.exec(text.slice(indent));
-    if (dash) cursor += dash[0].length;
-    let valueStart = cursor;
-    const key = yamlKey(source, cursor, end);
-    if (key) {
-      pushToken(tokens, cursor, key.nameEnd, "property");
-      valueStart = key.colon + 1;
-    }
-    scanYamlValue(source, valueStart, end, tokens, "#");
-    if (/(?:^|\s)[|>][+-]?\d?\s*(?:#.*)?$/.test(text.slice(valueStart - start))) blockIndent = indent;
-  }
-  return tokens;
-}
-function scanIni(source, def) {
-  const tokens = [], comments = (def.line ?? []).join("");
-  for (const { start, end } of lineRanges(source)) {
-    const text = source.slice(start, end), indent = /^\s*/.exec(text)[0].length, first = text[indent];
-    if (first === void 0) continue;
-    if (comments.includes(first)) {
-      pushToken(tokens, start + indent, end, "comment");
-      continue;
-    }
-    if (first === "[") {
-      const close = text.indexOf("]", indent);
-      const stop = close < 0 ? end : start + close + 1;
-      pushToken(tokens, start + indent, stop, "type");
-      scanYamlValue(source, stop, end, tokens, comments);
-      continue;
-    }
-    const key = /^("[^"\n]*"|'[^'\n]*'|[^\s=:#;"']+(?:\s+[^\s=:#;"']+)*)\s*[=:]/.exec(text.slice(indent));
-    let valueStart = start + indent;
-    if (key) {
-      pushToken(tokens, start + indent, start + indent + key[1].length, "property");
-      valueStart = start + indent + key[0].length;
-    }
-    scanYamlValue(source, valueStart, end, tokens, comments);
-  }
-  return tokens;
-}
-function scanMarkup(source) {
-  const tokens = [];
-  let index = 0;
-  while (index < source.length) {
-    const open = source.indexOf("<", index);
-    if (open < 0) break;
-    if (source.startsWith("<!--", open)) {
-      const close = source.indexOf("-->", open + 4);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, open, end, "comment");
-      index = end;
-      continue;
-    }
-    if (source.startsWith("<![CDATA[", open)) {
-      const close = source.indexOf("]]>", open);
-      const end = close < 0 ? source.length : close + 3;
-      pushToken(tokens, open, end, "string");
-      index = end;
-      continue;
-    }
-    const name = /<([/?!]?)([A-Za-z][\w:.-]*|DOCTYPE)?/y;
-    name.lastIndex = open;
-    const found = name.exec(source);
-    if (!found || !found[2]) {
-      index = open + 1;
-      continue;
-    }
-    pushToken(tokens, open + 1, open + found[0].length, "keyword");
-    index = open + found[0].length;
-    while (index < source.length && source[index] !== ">") {
-      const character = source[index];
-      if (character === '"' || character === "'") {
-        const close = source.indexOf(character, index + 1);
-        const end = close < 0 ? source.length : close + 1;
-        pushToken(tokens, index, end, "string");
-        index = end;
-        continue;
-      }
-      const attribute = /[A-Za-z_:@#][\w:.@#-]*/y;
-      attribute.lastIndex = index;
-      const matched = attribute.exec(source);
-      if (matched) {
-        pushToken(tokens, index, index + matched[0].length, "property");
-        index += matched[0].length;
-        continue;
-      }
-      index++;
-    }
-    if (source[index] === ">") index++;
-  }
-  return tokens;
-}
-function scanCss(source) {
-  const tokens = [];
-  let index = 0, depth = 0;
-  while (index < source.length) {
-    const character = source[index];
-    if (/\s/.test(character)) {
-      index++;
-      continue;
-    }
-    if (source.startsWith("/*", index)) {
-      const close = source.indexOf("*/", index + 2);
-      const end = close < 0 ? source.length : close + 2;
-      pushToken(tokens, index, end, "comment");
-      index = end;
-      continue;
-    }
-    if (character === '"' || character === "'") {
-      const end = scanQuoted(source, index, character, true, false);
-      pushToken(tokens, index, end, "string");
-      index = end;
-      continue;
-    }
-    if (character === "{") {
-      depth++;
-      index++;
-      continue;
-    }
-    if (character === "}") {
-      depth = Math.max(0, depth - 1);
-      index++;
-      continue;
-    }
-    if (character === "@") {
-      const match = /@[\w-]+/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "keyword");
-        index += found2[0].length;
-        continue;
-      }
-    }
-    if (character === "!") {
-      const match = /!\s*important/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "keyword");
-        index += found2[0].length;
-        continue;
-      }
-    }
-    if (character === "#" && depth > 0) {
-      const match = /#[\da-fA-F]{3,8}\b/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
-      }
-    }
-    if (depth > 0 && (/\d/.test(character) || (character === "-" || character === "." || character === "+") && /\d/.test(source[index + 1] ?? ""))) {
-      const match = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?(?:%|[a-zA-Z]+)?/y;
-      match.lastIndex = index;
-      const found2 = match.exec(source);
-      if (found2 && !isIdentChar(source[index - 1])) {
-        pushToken(tokens, index, index + found2[0].length, "number");
-        index += found2[0].length;
-        continue;
-      }
-    }
-    const word = /-?[\p{L}_][\p{L}\p{N}_-]*/uy;
-    word.lastIndex = index;
-    const found = word.exec(source);
-    if (found) {
-      const end = index + found[0].length;
-      let back = index - 1;
-      while (back >= 0 && /\s/.test(source[back])) back--;
-      const before = back >= 0 ? source[back] : "";
-      if (depth > 0 && /^\s*:(?!:)/.test(source.slice(end, end + 8)) && (before === "{" || before === ";" || before === "")) pushToken(tokens, index, end, "property");
-      else if (source[end] === "(") pushToken(tokens, index, end, "function");
-      index = end;
-      continue;
-    }
-    if (depth === 0 && (character === "." || character === "#")) {
-      const match = /[.#][\p{L}_-][\p{L}\p{N}_-]*/uy;
-      match.lastIndex = index;
-      const matched = match.exec(source);
-      if (matched) {
-        pushToken(tokens, index, index + matched[0].length, "type");
-        index += matched[0].length;
-        continue;
-      }
-    }
-    index++;
-  }
-  return tokens;
-}
-function tokenizeCode(source, language2) {
-  const id = resolveCodeLanguage(language2);
-  if (id === void 0 || typeof source !== "string" || source.length === 0 || source.length > CODE_HIGHLIGHT_MAX_LENGTH) return [];
-  const def = LANGUAGES[id];
-  let tokens;
-  switch (def.kind) {
-    case "yaml":
-      tokens = scanYaml(source);
-      break;
-    case "ini":
-      tokens = scanIni(source, def);
-      break;
-    case "markup":
-      tokens = scanMarkup(source);
-      break;
-    case "css":
-      tokens = scanCss(source);
-      break;
-    default:
-      tokens = scanGeneric(source, def);
-  }
-  return tokens.filter((token) => token.end > token.start).sort((a, b) => a.start - b.start);
-}
-function codeLineRuns(tokens, start, end, source) {
-  const runs = [];
-  const push = (from, to, kind) => {
-    if (kind === void 0 || source === void 0 || !source.slice(from, to).includes("	")) {
-      runs.push(kind === void 0 ? { start: from, end: to } : { start: from, end: to, kind });
-      return;
-    }
-    let at = from;
-    for (let index = from; index < to; index++) {
-      if (source[index] !== "	") continue;
-      if (index > at) runs.push({ start: at, end: index, kind });
-      runs.push({ start: index, end: index + 1 });
-      at = index + 1;
-    }
-    if (at < to) runs.push({ start: at, end: to, kind });
-  };
-  let cursor = start;
-  for (const token of tokens) {
-    if (token.end <= start) continue;
-    if (token.start >= end) break;
-    const from = Math.max(token.start, start), to = Math.min(token.end, end);
-    if (from > cursor) push(cursor, from);
-    push(from, to, token.kind);
-    cursor = to;
-  }
-  if (cursor < end) push(cursor, end);
-  return runs;
-}
-var distance = (a, b) => Math.hypot(...channels(a).map((value, index) => value - channels(b)[index]));
-var FALLBACK = { keyword: "#C4B5FD", string: "#86EFAC", number: "#FCD34D", function: "#93C5FD", type: "#67E8F9", property: "#F9A8D4", comment: "#94A3B8" };
-function codeSyntaxPalette(theme2 = {}, options = {}) {
-  const background = normalize(options.background) ?? CODE_PANEL_BACKGROUND, plain = normalize(options.foreground) ?? CODE_PANEL_FOREGROUND;
-  const minimum = options.minimumContrast ?? CODE_SYNTAX_MIN_CONTRAST;
-  const palette = { plain: legible(plain, background, minimum) };
-  const taken = [palette.plain];
-  const slots = [["keyword", theme2.primary], ["string", theme2.accent], ["number", theme2.secondary], ["comment", theme2.mutedText], ["function", void 0], ["type", void 0], ["property", void 0]];
-  for (const [kind, themed] of slots) {
-    const candidates = [normalize(themed), FALLBACK[kind]].filter((value) => value !== void 0).map((value) => legible(value, background, minimum));
-    let [h, s, l] = toHsl(FALLBACK[kind]);
-    let pick = candidates.find((candidate) => taken.every((other) => distance(candidate, other) >= 48));
-    for (let turn = 0; pick === void 0 && turn < 9; turn++) {
-      h += 40;
-      const candidate = legible(fromHsl(h, s, l), background, minimum);
-      if (taken.every((other) => distance(candidate, other) >= 48)) pick = candidate;
-    }
-    palette[kind] = pick ?? candidates[candidates.length - 1];
-    taken.push(palette[kind]);
-  }
-  return palette;
-}
-function codeSyntaxPaletteForScheme(scheme, options = {}) {
-  const record = scheme && typeof scheme === "object" ? scheme : {};
-  const pick = (role, slot, fallback) => normalize(record[role]) ?? normalize(record[slot]) ?? fallback;
-  return codeSyntaxPalette({ primary: pick("primary", "accent1", "#2563EB"), secondary: pick("secondary", "accent2", "#0F766E"), accent: pick("accent", "accent3", "#F59E0B") }, options);
-}
-
-// src/metric-trend.ts
-var METRIC_TREND_SHAPES = Object.freeze({ up: "upArrow", down: "downArrow", flat: "rightArrow" });
-var METRIC_TREND_MIN_CONTRAST = 4.5;
-var SEMANTIC = {
-  up: { light: "#15803D", dark: "#4ADE80" },
-  down: { light: "#B91C1C", dark: "#F87171" }
-};
-function metricTrendColor(trend, options) {
-  const background = normalize(options.background) ?? "#FFFFFF";
-  if (trend === "flat") return legible(normalize(options.neutral) ?? (luminance(background) < 0.5 ? "#CBD5E1" : "#475569"), background, METRIC_TREND_MIN_CONTRAST);
-  const pair = SEMANTIC[trend];
-  return legible(luminance(background) < 0.5 ? pair.dark : pair.light, background, METRIC_TREND_MIN_CONTRAST);
-}
-function metricTrendPoints(shape, box) {
-  const { x: l, y: t, width: w, height: h } = box, r = l + w, b = t + h, hc = l + w / 2, vc = t + h / 2, ss = Math.min(w, h);
-  if (shape === "rightArrow") {
-    const x12 = r - ss * 0.5, y1 = vc - h * 0.25, y22 = vc + h * 0.25;
-    return [[l, y1], [x12, y1], [x12, t], [r, vc], [x12, b], [x12, y22], [l, y22]];
-  }
-  const dy = ss * 0.5, x1 = hc - w * 0.25, x2 = hc + w * 0.25;
-  if (shape === "upArrow") {
-    const y22 = t + dy;
-    return [[l, y22], [hc, t], [r, y22], [x2, y22], [x2, b], [x1, b], [x1, y22]];
-  }
-  const y2 = b - dy;
-  return [[l, y2], [x1, y2], [x1, t], [x2, t], [x2, y2], [r, y2], [hc, b]];
-}
-function metricTrendMark(layout2, options) {
-  const part = layout2.parts.find((candidate) => candidate.role === "trend");
-  if (!part || !part.visible || !part.fit || part.fit.sourceLines.length === 0) return void 0;
-  const trend = part.text.trim();
-  if (!Object.hasOwn(METRIC_TREND_SHAPES, trend)) return void 0;
-  const line = part.fit.sourceLines[0], origin = part.linePositions[0];
-  if (!origin || line.width <= 0) return void 0;
-  const size = part.fit.fontSize * 0.72, gap = part.fit.fontSize * 0.3, left = part.box.x, right = part.box.x + part.box.width;
-  const after = origin.x + line.width + gap, before = origin.x - gap - size;
-  const fitsAfter = after + size <= right + 0.01, fitsBefore = before >= left - 0.01;
-  const x = layout2.alignment === "left" ? fitsAfter ? after : fitsBefore ? before : void 0 : fitsBefore ? before : fitsAfter ? after : void 0;
-  if (x === void 0) return void 0;
-  const shape = METRIC_TREND_SHAPES[trend], box = { x, y: origin.baseline - size, width: size, height: size };
-  return { trend, shape, box, points: metricTrendPoints(shape, box), color: metricTrendColor(trend, options), ariaLabel: `Trend: ${trend}`, path: part.path };
-}
-
-// src/pattern-fills.ts
-var PATTERN_PRESETS = Object.freeze([
-  "pct5",
-  "pct10",
-  "pct20",
-  "pct25",
-  "pct30",
-  "pct40",
-  "pct50",
-  "pct60",
-  "pct70",
-  "pct75",
-  "pct80",
-  "pct90",
-  "horz",
-  "vert",
-  "ltHorz",
-  "ltVert",
-  "dkHorz",
-  "dkVert",
-  "narHorz",
-  "narVert",
-  "dashHorz",
-  "dashVert",
-  "cross",
-  "dnDiag",
-  "upDiag",
-  "ltDnDiag",
-  "ltUpDiag",
-  "dkDnDiag",
-  "dkUpDiag",
-  "wdDnDiag",
-  "wdUpDiag",
-  "dashDnDiag",
-  "dashUpDiag",
-  "diagCross",
-  "smCheck",
-  "lgCheck",
-  "smGrid",
-  "lgGrid",
-  "dotGrid",
-  "smConfetti",
-  "lgConfetti",
-  "horzBrick",
-  "diagBrick",
-  "solidDmnd",
-  "openDmnd",
-  "dotDmnd",
-  "plaid",
-  "sphere",
-  "weave",
-  "divot",
-  "shingle",
-  "wave",
-  "trellis",
-  "zigZag"
-]);
-var PATTERN_PRESET_ALIASES = Object.freeze({ diagStripe: "wdUpDiag" });
-var PATTERN_TILE_SIZE = 8;
-var MEASURED = {
-  pct5: "#......./......../......../......../....#.../......../......../........",
-  pct10: "#......./......../....#.../......../#......./......../....#.../........",
-  pct20: "#...#.../......../..#...#./......../#...#.../......../..#...#./........",
-  pct25: "#...#.../..#...#./#...#.../..#...#./#...#.../..#...#./#...#.../..#...#.",
-  pct30: "#.#.#.#./.#...#../#.#.#.#./...#...#/#.#.#.#./.#...#../#.#.#.#./...#...#",
-  pct40: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#...#/#.#.#.#./.#.#.#.#/#.#.#.#./...#.#.#",
-  pct50: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#",
-  pct60: "###.###./.#.#.#.#/#.###.##/.#.#.#.#/###.###./.#.#.#.#/#.###.##/.#.#.#.#",
-  pct70: ".###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#",
-  pct75: ".###.###/########/##.###.#/########/.###.###/########/##.###.#/########",
-  pct80: "###.####/########/#######./########/###.####/########/#######./########",
-  pct90: "########/########/########/####.###/########/########/########/.#######",
-  horz: "########/......../......../......../......../......../......../........",
-  vert: "#......./#......./#......./#......./#......./#......./#......./#.......",
-  ltHorz: "########/......../......../......../########/......../......../........",
-  ltVert: "#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#...",
-  dkHorz: "########/########/......../......../########/########/......../........",
-  dkVert: "##..##../##..##../##..##../##..##../##..##../##..##../##..##../##..##..",
-  narHorz: "########/......../########/......../########/......../########/........",
-  narVert: ".#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#",
-  dashHorz: "####..../......../......../......../....####/......../......../........",
-  dashVert: "#......./#......./#......./#......./....#.../....#.../....#.../....#...",
-  cross: "########/#......./#......./#......./#......./#......./#......./#.......",
-  dnDiag: "#......./.#....../..#...../...#..../....#.../.....#../......#./.......#",
-  upDiag: ".......#/......#./.....#../....#.../...#..../..#...../.#....../#.......",
-  ltDnDiag: "#...#.../.#...#../..#...#./...#...#/#...#.../.#...#../..#...#./...#...#",
-  ltUpDiag: "...#...#/..#...#./.#...#../#...#.../...#...#/..#...#./.#...#../#...#...",
-  dkDnDiag: "##..##../.##..##./..##..##/#..##..#/##..##../.##..##./..##..##/#..##..#",
-  dkUpDiag: "..##..##/.##..##./##..##../#..##..#/..##..##/.##..##./##..##../#..##..#",
-  wdDnDiag: "##.....#/###...../.###..../..###.../...###../....###./.....###/#.....##",
-  wdUpDiag: "#.....##/.....###/....###./...###../..###.../.###..../###...../##.....#",
-  dashDnDiag: "......../......../#...#.../.#...#../..#...#./...#...#/......../........",
-  dashUpDiag: "......../......../...#...#/..#...#./.#...#../#...#.../......../........",
-  diagCross: "#......#/.#....#./..#..#../...##.../...##.../..#..#../.#....#./#......#",
-  smCheck: "#..##..#/.##..##./.##..##./#..##..#/#..##..#/.##..##./.##..##./#..##..#",
-  lgCheck: "####..../####..../####..../####..../....####/....####/....####/....####",
-  smGrid: "########/#...#.../#...#.../#...#.../########/#...#.../#...#.../#...#...",
-  lgGrid: "########/#......./#......./#......./#......./#......./#......./#.......",
-  dotGrid: "#.#.#.#./......../#......./......../#......./......../#......./........",
-  smConfetti: "#......./....#.../.#....../......#./...#..../.......#/..#...../.....#..",
-  lgConfetti: "#.##...#/..##..../......##/...##.##/##.##.../##....../....##../#...##.#",
-  horzBrick: "########/#......./#......./#......./########/....#.../....#.../....#...",
-  diagBrick: ".......#/......#./.....#../....#.../...##.../..#..#../.#....#./#......#",
-  solidDmnd: "...#..../..###.../.#####../#######./.#####../..###.../...#..../........",
-  openDmnd: "#.....#./.#...#../..#.#.../...#..../..#.#.../.#...#../#.....#./.......#",
-  dotDmnd: "#......./......../..#...#./......../....#.../......../..#...#./........",
-  plaid: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/####..../####..../####..../####....",
-  sphere: ".###.###/#...#..#/#...####/#...####/.###.###/#..##.../#####.../#####...",
-  weave: "#...#.../.#.#.#../..#...#./.#...#.#/#...#.../...#.#../..#...#./.#.#...#",
-  divot: "......../...#..../....#.../...#..../......../#......./.......#/#.......",
-  shingle: "......##/#....#../.#..#.../..##..../....##../......#./.......#/.......#",
-  wave: "......../...##.../..#..#.#/##....../......../...##.../..#..#.#/##......",
-  trellis: "########/.##..##./########/#..##..#/########/.##..##./########/#..##..#",
-  zigZag: "#......#/.#....#./..#..#../...##.../#......#/.#....#./..#..#../...##..."
-};
-function rows(preset) {
-  const art = MEASURED[preset];
-  if (!art) return void 0;
-  return art.split("/").map((row) => [...row].reduce((bits, cell, index) => cell === "#" ? bits | 128 >> index : bits, 0));
-}
-var BITMAPS = /* @__PURE__ */ new Map();
-for (const preset of PATTERN_PRESETS) {
-  const bitmap = rows(preset);
-  if (bitmap) BITMAPS.set(preset, Object.freeze(bitmap));
-}
-function resolvePatternPreset(preset) {
-  if (typeof preset !== "string") return void 0;
-  if (BITMAPS.has(preset)) return preset;
-  return Object.hasOwn(PATTERN_PRESET_ALIASES, preset) ? PATTERN_PRESET_ALIASES[preset] : void 0;
-}
-function patternBitmap(preset) {
-  const resolved = resolvePatternPreset(preset);
-  return resolved === void 0 ? void 0 : BITMAPS.get(resolved);
-}
-function patternRuns(preset) {
-  const bitmap = patternBitmap(preset);
-  if (!bitmap) return void 0;
-  const runs = [];
-  bitmap.forEach((row, y) => {
-    for (let x = 0; x < 8; x++) {
-      if (!(row & 128 >> x)) continue;
-      const start = x;
-      while (x + 1 < 8 && row & 128 >> x + 1) x++;
-      runs.push({ x: start, y, width: x - start + 1 });
-    }
-  });
-  return runs;
-}
-
-export { CODE_HIGHLIGHT_LANGUAGES, CODE_HIGHLIGHT_MAX_LENGTH, CODE_PANEL_BACKGROUND, CODE_PANEL_FOREGROUND, CODE_SYNTAX_MIN_CONTRAST, METRIC_TREND_MIN_CONTRAST, METRIC_TREND_SHAPES, PATTERN_PRESETS, PATTERN_PRESET_ALIASES, PATTERN_TILE_SIZE, bundlePresentation, codeLineRuns, codeSyntaxPalette, codeSyntaxPaletteForScheme, metricTrendColor, metricTrendMark, metricTrendPoints, patternBitmap, patternRuns, resolveCodeLanguage, resolvePatternPreset, tokenizeCode };
+export { bundle, stats };