@openpresentation/opf 0.11.4 → 0.12.1

package/dist/index.js

@@ -1,16 +1,18 @@
-export { specFileEntries, specFileKinds, specFilePaths } from './chunk-HJL64ETN.js';
+export { specFileEntries, specFileKinds, specFilePaths } from './chunk-GJKJL4YY.js';
 export { getLayoutPreview, hasLayoutPreview, layoutPreviewIndex, layoutPreviewSlugs, layoutPreviews } from './chunk-PIQXLBBJ.js';
-export { lintPresentation, lintSource } from './chunk-3OJN7QAW.js';
-export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-RXNFDGPC.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-NSVVQ52O.js';
-import { isRecord, visitContentPayloads, bareIdPattern } from './chunk-FDCWQHWO.js';
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation } from './chunk-FDCWQHWO.js';
-import { resolveFontSchemeReference, DEFAULT_FONT_SCHEME, resolveFontFamilies } from './chunk-3H2U7FDR.js';
-export { DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, MAX_COMPOSITION_DEPTH, OPFCompositionError, PICTURE_BULLET_SCALE, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, formatFurnitureDate, formatSlideNumber, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveSocialProfile, resolveTextStyle, textColorForFill, textWidthMeasurer, wrapText } from './chunk-3H2U7FDR.js';
-export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-KJKASEPE.js';
-import { catalogs, catalogEntries } from './chunk-AEUSVEUY.js';
-export { audiences, catalogEntries, catalogIndexes, catalogKinds, catalogSchemaNames, catalogs, chartTypes, colorSchemes, fontSchemes, languages, layouts, narratives, purposes, socialPlatforms, themes, tones } from './chunk-AEUSVEUY.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';
+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';
+export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-WXSPETQ6.js';
 
 // src/bundle.ts
 function reportKey(kind, id) {
@@ -209,267 +211,929 @@ function bundlePresentation(value) {
   return { presentation: presentation2, report };
 }
 
-// src/script-fonts.ts
-var eastAsianScripts = /* @__PURE__ */ new Set(["Hani", "Hans", "Hant", "Hanb", "Jpan", "Kore", "Hang", "Jamo", "Hira", "Kana", "Hrkt", "Bopo", "Yiii"]);
-var complexScripts = /* @__PURE__ */ new Set([
-  "Arab",
-  "Hebr",
-  "Syrc",
-  "Thaa",
-  "Nkoo",
-  "Adlm",
-  "Rohg",
-  "Mand",
-  "Samr",
-  "Deva",
-  "Beng",
-  "Guru",
-  "Gujr",
-  "Orya",
-  "Taml",
-  "Telu",
-  "Knda",
-  "Mlym",
-  "Sinh",
-  "Thai",
-  "Laoo",
-  "Tibt",
-  "Mymr",
-  "Khmr",
-  "Mong",
-  "Bali",
-  "Java",
-  "Lana",
-  "Tale",
-  "Talu",
-  "Cakm",
-  "Olck"
-]);
-var rtlScripts = /* @__PURE__ */ new Set(["Arab", "Hebr", "Syrc", "Thaa", "Nkoo", "Adlm", "Rohg", "Mand", "Samr"]);
-var latinSlotScripts = /* @__PURE__ */ new Set(["Latn", "Cyrl", "Grek", "Zyyy", "Zzzz"]);
-var deprecatedLanguages = { iw: "he", in: "id", ji: "yi" };
-var matchingLanguages = { ...deprecatedLanguages, no: "nb", zsm: "ms", ku: "kmr" };
-var likelyScripts = {
-  zh: { script: "Hans", regions: { TW: "Hant", HK: "Hant", MO: "Hant" } },
-  sr: { script: "Cyrl", regions: { ME: "Latn" } },
-  pa: { script: "Guru", regions: { PK: "Arab" } },
-  az: { script: "Latn", regions: { IR: "Arab" } },
-  uz: { script: "Latn", regions: { AF: "Arab" } },
-  bs: { script: "Latn" },
-  mn: { script: "Cyrl", regions: { CN: "Mong" } },
-  ms: { script: "Latn" }
+// 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 bareLanguageId = /^[a-z][a-z0-9-]*$/;
-var strongRtl = /[\u200F\u061C]|(?=\p{L})[\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Adlam}\p{Script=Hanifi_Rohingya}\p{Script=Mandaic}\p{Script=Samaritan}\p{Script=Mende_Kikakui}\p{Script=Imperial_Aramaic}\p{Script=Phoenician}\p{Script=Kharoshthi}\p{Script=Old_South_Arabian}\p{Script=Old_North_Arabian}\p{Script=Avestan}\p{Script=Inscriptional_Parthian}\p{Script=Inscriptional_Pahlavi}\p{Script=Psalter_Pahlavi}\p{Script=Old_Turkic}\p{Script=Old_Hungarian}\p{Script=Nabataean}\p{Script=Palmyrene}\p{Script=Hatran}\p{Script=Manichaean}\p{Script=Sogdian}\p{Script=Old_Sogdian}\p{Script=Elymaic}\p{Script=Chorasmian}\p{Script=Yezidi}\p{Script=Cypriot}\p{Script=Lydian}\p{Script=Meroitic_Cursive}\p{Script=Meroitic_Hieroglyphs}\u{10F70}-\u{10FAF}\u{10D40}-\u{10D8F}]/u;
-var strongLtr = /[\u200E\p{L}\p{Nl}]/u;
-function paragraphDirection(text2, deckDirection) {
-  if (deckDirection !== "rtl") return "ltr";
-  let isolates = 0;
-  for (const char of String(text2 ?? "")) {
-    if (char === "\u2066" || char === "\u2067" || char === "\u2068") isolates += 1;
-    else if (char === "\u2069") isolates = Math.max(0, isolates - 1);
-    else if (isolates === 0) {
-      if (strongRtl.test(char)) return "rtl";
-      if (strongLtr.test(char)) return "ltr";
+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());
   }
-  return "rtl";
-}
-function scriptFontRole(script) {
-  const code = normalizeScript(script);
-  if (code && eastAsianScripts.has(code)) return "eastAsian";
-  if (code && complexScripts.has(code)) return "complexScript";
-  return "latin";
-}
-function normalizeScript(value) {
-  if (typeof value !== "string" || !/^[A-Za-z]{4}$/.test(value)) return void 0;
-  return value.slice(0, 1).toUpperCase() + value.slice(1).toLowerCase();
-}
-function text(value) {
-  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
-}
-var tagSyntax = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
-function splitTag(tag) {
-  if (!tagSyntax.test(tag)) return void 0;
-  const [first = "", ...rest] = tag.split("-");
-  const language2 = first.toLowerCase();
-  if (language2 === "und") return void 0;
-  let script;
-  let region;
-  for (const subtag of rest) {
-    if (subtag.length === 1) break;
-    if (!script && !region && /^[A-Za-z]{4}$/.test(subtag)) script = normalizeScript(subtag);
-    else if (!region && /^(?:[A-Za-z]{2}|\d{3})$/.test(subtag)) region = subtag.toUpperCase();
+  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 { language: language2, script, region };
-}
-function canonicalTag(tag) {
-  let extension = false;
-  return tag.split("-").map((subtag, index) => {
-    const lower = subtag.toLowerCase();
-    if (index === 0) return deprecatedLanguages[lower] ?? lower;
-    if (extension) return lower;
-    if (subtag.length === 1) {
-      extension = true;
-      return lower;
-    }
-    if (/^[A-Za-z]{4}$/.test(subtag)) return normalizeScript(subtag);
-    if (/^[A-Za-z]{2}$/.test(subtag)) return subtag.toUpperCase();
-    return lower;
-  }).join("-");
-}
-function vendoredScript(language2, region) {
-  const entry = likelyScripts[language2];
-  return entry ? (region && entry.regions?.[region]) ?? entry.script : void 0;
-}
-function inferScript(tag) {
-  const parts = splitTag(tag);
-  if (!parts) return void 0;
-  const known = parts.script ?? vendoredScript(matchingLanguages[parts.language] ?? parts.language, parts.region);
-  if (known) return known;
-  try {
-    return normalizeScript(new Intl.Locale(tag).maximize().script);
-  } catch {
-    return void 0;
+  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 inlineRecords(document, kind) {
-  const kinds = isRecord(document.catalogs) ? document.catalogs : {};
-  const entry = kinds[kind];
-  return isRecord(entry) && Array.isArray(entry.records) ? entry.records.filter(isRecord) : [];
-}
-function allRecords(document, kind) {
-  return [...inlineRecords(document, kind), ...catalogs[kind]];
-}
-function resolveReference(lookup, kind, reference) {
-  if (typeof reference === "string") return lookup(kind, reference);
-  if (!isRecord(reference)) return void 0;
-  const base = typeof reference.id === "string" ? lookup(kind, reference.id) : void 0;
-  return { ...base, ...reference };
-}
-function matchLanguageTag(document, tag) {
-  const wanted = splitTag(tag);
-  if (!wanted) return void 0;
-  const records = allRecords(document, "languages").filter((record) => typeof record.bcp47 === "string");
-  const key = canonicalTag(tag).toLowerCase();
-  const exact = records.find((record) => canonicalTag(record.bcp47).toLowerCase() === key);
-  if (exact) return exact;
-  const language2 = matchingLanguages[wanted.language] ?? wanted.language;
-  const script = wanted.script ?? vendoredScript(language2, wanted.region);
-  const candidates = records.flatMap((record) => {
-    const parts = splitTag(record.bcp47);
-    if (!parts || (matchingLanguages[parts.language] ?? parts.language) !== language2) return [];
-    const recordScript = normalizeScript(record.script) ?? parts.script ?? vendoredScript(language2, parts.region);
-    if (script && recordScript && script !== recordScript) return [];
-    return [{ record, region: parts.region }];
-  });
-  return candidates.find((candidate) => wanted.region && candidate.region === wanted.region)?.record ?? candidates.find((candidate) => !candidate.region)?.record ?? candidates[0]?.record;
-}
-function resolveLanguage(document, lookup, reference) {
-  if (typeof reference === "string") {
-    const value = reference.trim();
-    const byId = bareLanguageId.test(value) ? lookup("languages", value) : void 0;
-    if (byId) return { record: byId, languageId: value };
-    if (/^[a-z][a-z0-9+.-]*:/i.test(value) || !splitTag(value)) return void 0;
-    const matched = matchLanguageTag(document, value);
-    if (matched) return { record: matched, authoredTag: value, languageId: text(matched.id) };
-    return inferScript(value) ? { record: {}, authoredTag: value } : void 0;
+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;
   }
-  if (!isRecord(reference)) return void 0;
-  const authoredTag = text(reference.bcp47);
-  if (authoredTag !== void 0 && !splitTag(authoredTag)) return void 0;
-  const base = typeof reference.id === "string" ? lookup("languages", reference.id) : authoredTag ? matchLanguageTag(document, authoredTag) : void 0;
-  const record = { ...base, ...reference };
-  const tag = text(record.bcp47);
-  if (!tag || !splitTag(tag)) return void 0;
-  return { record, authoredTag, authoredOoxmlLang: text(reference.ooxmlLang), languageId: text(base?.id) };
-}
-function pairFamilies(value) {
-  if (!isRecord(value)) return void 0;
-  const major = text(value.major);
-  const minor = text(value.minor);
-  const heading = major ?? minor;
-  const body = minor ?? major;
-  return heading && body ? { heading, body } : void 0;
-}
-function schemeServesLanguage(scheme, language2) {
-  const entries = Array.isArray(scheme.languages) ? scheme.languages.filter((entry) => typeof entry === "string") : [];
-  if (entries.length === 0) return true;
-  const name = text(language2.name)?.toLowerCase();
-  if (!name) return false;
-  const base = name.replace(/\s*\([^)]*\)\s*$/, "");
-  return entries.some((entry) => {
-    const value = entry.trim().toLowerCase();
-    return value === name || value === base;
-  });
+  ranges.push({ start: cursor, end: source.length });
+  return ranges;
 }
-function resolveScriptFonts(input, options = {}) {
-  const document = isRecord(input) ? input : {};
-  const lookup = (kind, id) => inlineRecords(document, kind).find((record2) => record2.id === id) ?? catalogs[kind].find((record2) => record2.id === id);
-  let design = isRecord(document.design) ? document.design : {};
-  if (options.slideIndex !== void 0) {
-    const slides = Array.isArray(document.slides) ? document.slides : [];
-    if (!Number.isInteger(options.slideIndex) || options.slideIndex < 0 || options.slideIndex >= slides.length) {
-      throw new RangeError(`slideIndex must be an integer between 0 and ${slides.length - 1}.`);
-    }
-    const slide = slides[options.slideIndex];
-    if (isRecord(slide) && isRecord(slide.design)) design = { ...design, ...slide.design };
+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;
   }
-  const theme2 = resolveReference(lookup, "themes", design.theme ?? "minimal") ?? {};
-  const scheme = resolveFontSchemeReference(design.fontScheme ?? theme2.fontScheme ?? DEFAULT_FONT_SCHEME, (id) => lookup("fontSchemes", id)).scheme;
-  const latin = resolveFontFamilies(scheme);
-  const fromOption = options.language !== void 0 ? resolveLanguage(document, lookup, options.language) : void 0;
-  const fromDocument = fromOption ? void 0 : resolveLanguage(document, lookup, document.language);
-  const requestedDefault = text(options.defaultLanguage);
-  const fallbackTag = requestedDefault && splitTag(requestedDefault) ? requestedDefault : "en-US";
-  const language2 = fromOption ?? fromDocument ?? resolveLanguage(document, lookup, fallbackTag) ?? { record: {}, authoredTag: fallbackTag };
-  const languageSource = fromOption ? "option" : fromDocument ? "document" : "default";
-  const record = language2.record;
-  const bcp47 = canonicalTag(language2.authoredTag ?? text(record.bcp47) ?? fallbackTag);
-  const curated = text(record.ooxmlLang);
-  const lang = language2.authoredOoxmlLang ? canonicalTag(language2.authoredOoxmlLang) : language2.authoredTag && splitTag(language2.authoredTag)?.region ? canonicalTag(language2.authoredTag) : curated ? canonicalTag(curated) : bcp47;
-  const parts = splitTag(bcp47);
-  const script = normalizeScript(record.script) ?? (language2.languageId ? parts?.script ?? (parts ? vendoredScript(matchingLanguages[parts.language] ?? parts.language, parts.region) : void 0) ?? normalizeScript(matchLanguageTag({}, bcp47)?.script) : inferScript(bcp47)) ?? "Zzzz";
-  const scriptRole = scriptFontRole(script);
-  const declaredDirection = record.direction;
-  const direction = declaredDirection === "rtl" || declaredDirection === "ltr" ? declaredDirection : rtlScripts.has(script) ? "rtl" : "ltr";
-  const app = options.app ?? "PowerPoint";
-  const preferred = app === "Google Slides" ? record.googleFontScheme : record.fontScheme;
-  const alternate = app === "Google Slides" ? record.fontScheme : record.googleFontScheme;
-  const languageScheme = resolveReference(lookup, "fontSchemes", preferred) ?? resolveReference(lookup, "fontSchemes", alternate);
-  const languageFamilies = pairFamilies(languageScheme);
-  const schemeAdmitsLanguage = schemeServesLanguage(scheme, record);
-  const slot = (role, family) => {
-    const explicit = pairFamilies(scheme[role]);
-    if (explicit) return { ...explicit, source: "fontScheme" };
-    if (scheme.languageFamily === family && schemeAdmitsLanguage) return { ...latin, source: "schemeFamily" };
-    if (scriptRole === role && languageFamilies) return { ...languageFamilies, source: "language" };
-    return { heading: latin.heading, body: latin.body, source: "latin" };
-  };
-  const eastAsian = slot("eastAsian", "ea");
-  const complexScript = slot("complexScript", "cs");
-  const heading = { latin: latin.heading, eastAsian: eastAsian.heading, complexScript: complexScript.heading };
-  const body = { latin: latin.body, eastAsian: eastAsian.body, complexScript: complexScript.body };
-  let supplement;
-  if (!latinSlotScripts.has(script)) {
-    const families = scriptRole === "latin" ? languageFamilies : (scriptRole === "eastAsian" ? eastAsian : complexScript).source === "latin" ? void 0 : { heading: heading[scriptRole], body: body[scriptRole] };
-    if (families) supplement = { script: script === "Kore" ? "Hang" : script, heading: families.heading, body: families.body };
+  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 {
-    ...body,
-    lang,
-    bcp47,
-    ...language2.languageId ? { languageId: language2.languageId } : {},
-    languageSource,
-    script,
-    scriptRole,
-    direction,
-    rtl: direction === "rtl",
-    heading,
-    body,
-    ...supplement ? { supplement } : {},
-    sources: { eastAsian: eastAsian.source, complexScript: complexScript.source }
+  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 { bundlePresentation, paragraphDirection, resolveScriptFonts, scriptFontRole };
+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 };