pptx-glimpse 1.1.2 → 3.0.0

package/dist/chunk-2AYNMYMC.js

@@ -0,0 +1,1554 @@
+// ../renderer/src/warning-logger.ts
+var PREFIX = "[pptx-glimpse]";
+var currentLevel = "off";
+var entries = [];
+var featureCounts = /* @__PURE__ */ new Map();
+function initWarningLogger(level) {
+  currentLevel = level;
+  entries = [];
+  featureCounts.clear();
+}
+function warn(feature, message, context) {
+  if (currentLevel === "off") return;
+  entries.push({ feature, message, ...context !== void 0 && { context } });
+  const existing = featureCounts.get(feature);
+  if (existing) {
+    existing.count++;
+  } else {
+    featureCounts.set(feature, { message, count: 1 });
+  }
+  if (currentLevel === "debug") {
+    const ctx = context ? ` (${context})` : "";
+    console.warn(`${PREFIX} SKIP: ${feature} - ${message}${ctx}`);
+  }
+}
+function debug(feature, message, context) {
+  if (currentLevel !== "debug") return;
+  entries.push({ feature, message, ...context !== void 0 && { context } });
+  const existing = featureCounts.get(feature);
+  if (existing) {
+    existing.count++;
+  } else {
+    featureCounts.set(feature, { message, count: 1 });
+  }
+  const ctx = context ? ` (${context})` : "";
+  console.warn(`${PREFIX} DEBUG: ${feature} - ${message}${ctx}`);
+}
+function getWarningSummary() {
+  const features = [];
+  for (const [feature, { message, count }] of featureCounts) {
+    features.push({ feature, message, count });
+  }
+  return { totalCount: entries.length, features };
+}
+function flushWarnings() {
+  const summary = getWarningSummary();
+  if (currentLevel !== "off" && summary.features.length > 0) {
+    console.warn(`${PREFIX} Summary: ${summary.features.length} unsupported feature(s) detected`);
+    for (const { feature, count } of summary.features) {
+      console.warn(`  - ${feature}: ${count} occurrence(s)`);
+    }
+  }
+  entries = [];
+  featureCounts.clear();
+  return summary;
+}
+function getWarningEntries() {
+  return entries;
+}
+
+// ../renderer/src/font/font-mapping.ts
+var DEFAULT_FONT_MAPPING = {
+  // Latin fonts
+  Calibri: "Carlito",
+  "Calibri Light": "Carlito",
+  Arial: "Arimo",
+  "Times New Roman": "Tinos",
+  "Courier New": "Cousine",
+  Cambria: "Caladea",
+  // Japanese Gothic fonts -> Noto Sans JP
+  // Use "Noto Sans JP" instead of "Noto Sans CJK JP".
+  // NotoSansCJK TTC extracts only the first font, so it may not always be possible to obtain the JP variant.
+  // The font name matches the standalone NotoSansJP.ttf downloaded in the Docker environment.
+  \u30E1\u30A4\u30EA\u30AA: "Noto Sans JP",
+  Meiryo: "Noto Sans JP",
+  \u6E38\u30B4\u30B7\u30C3\u30AF: "Noto Sans JP",
+  "Yu Gothic": "Noto Sans JP",
+  "MS \u30B4\u30B7\u30C3\u30AF": "Noto Sans JP",
+  "MS Gothic": "Noto Sans JP",
+  "MS P\u30B4\u30B7\u30C3\u30AF": "Noto Sans JP",
+  "MS PGothic": "Noto Sans JP",
+  // Japanese Mincho fonts -> Noto Serif CJK JP
+  "MS \u660E\u671D": "Noto Serif CJK JP",
+  "MS Mincho": "Noto Serif CJK JP",
+  "MS P\u660E\u671D": "Noto Serif CJK JP",
+  "MS PMincho": "Noto Serif CJK JP",
+  \u6E38\u660E\u671D: "Noto Serif CJK JP",
+  "Yu Mincho": "Noto Serif CJK JP"
+};
+function createFontMapping(userMapping) {
+  if (!userMapping) return { ...DEFAULT_FONT_MAPPING };
+  return { ...DEFAULT_FONT_MAPPING, ...userMapping };
+}
+function normalizeFullWidth(s) {
+  return s.replace(/[\uff01-\uff5e]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/\u3000/g, " ");
+}
+function getMappedFont(fontFamily, mapping) {
+  if (!fontFamily) return null;
+  const direct = mapping[fontFamily];
+  if (direct !== void 0) return direct;
+  const normalized = normalizeFullWidth(fontFamily);
+  if (normalized !== fontFamily) {
+    const directNormalized = mapping[normalized];
+    if (directNormalized !== void 0) return directNormalized;
+  }
+  const lower = normalized.toLowerCase();
+  for (const key of Object.keys(mapping)) {
+    if (normalizeFullWidth(key).toLowerCase() === lower) {
+      return mapping[key];
+    }
+  }
+  return null;
+}
+
+// ../renderer/src/unsafe-type-assertion.ts
+function unsafeExternalInteropAssertion(value) {
+  return value;
+}
+function unsafeBrandAssertion(value) {
+  return value;
+}
+
+// ../renderer/src/data/font-metrics.ts
+var metricsData = {
+  Carlito: {
+    unitsPerEm: 2048,
+    ascender: 1950,
+    descender: -550,
+    defaultWidth: 991,
+    cjkWidth: 2048,
+    widths: {
+      " ": 463,
+      "!": 667,
+      '"': 821,
+      "#": 1020,
+      "$": 1038,
+      "%": 1464,
+      "&": 1397,
+      "'": 452,
+      "(": 621,
+      ")": 621,
+      "*": 1020,
+      "+": 1020,
+      ",": 511,
+      "-": 627,
+      ".": 517,
+      "/": 791,
+      "0": 1038,
+      "1": 1038,
+      "2": 1038,
+      "3": 1038,
+      "4": 1038,
+      "5": 1038,
+      "6": 1038,
+      "7": 1038,
+      "8": 1038,
+      "9": 1038,
+      ":": 548,
+      ";": 548,
+      "<": 1020,
+      "=": 1020,
+      ">": 1020,
+      "?": 949,
+      "@": 1831,
+      "A": 1185,
+      "B": 1114,
+      "C": 1092,
+      "D": 1260,
+      "E": 1e3,
+      "F": 941,
+      "G": 1292,
+      "H": 1276,
+      "I": 516,
+      "J": 653,
+      "K": 1064,
+      "L": 861,
+      "M": 1751,
+      "N": 1322,
+      "O": 1356,
+      "P": 1058,
+      "Q": 1378,
+      "R": 1112,
+      "S": 941,
+      "T": 998,
+      "U": 1314,
+      "V": 1162,
+      "W": 1822,
+      "X": 1063,
+      "Y": 998,
+      "Z": 959,
+      "[": 628,
+      "\\": 791,
+      "]": 628,
+      "^": 1020,
+      "_": 1020,
+      "`": 596,
+      "a": 981,
+      "b": 1076,
+      "c": 866,
+      "d": 1076,
+      "e": 1019,
+      "f": 625,
+      "g": 964,
+      "h": 1076,
+      "i": 470,
+      "j": 490,
+      "k": 931,
+      "l": 470,
+      "m": 1636,
+      "n": 1076,
+      "o": 1080,
+      "p": 1076,
+      "q": 1076,
+      "r": 714,
+      "s": 801,
+      "t": 686,
+      "u": 1076,
+      "v": 925,
+      "w": 1464,
+      "x": 887,
+      "y": 927,
+      "z": 809,
+      "{": 644,
+      "|": 943,
+      "}": 644,
+      "~": 1020,
+      "\xA0": 463,
+      "\xA1": 667,
+      "\xA2": 1020,
+      "\xA3": 1038,
+      "\xA4": 1020,
+      "\xA5": 1038,
+      "\xA6": 1020,
+      "\xA7": 1020,
+      "\xA8": 804,
+      "\xA9": 1709,
+      "\xAA": 824,
+      "\xAB": 1049,
+      "\xAC": 1020,
+      "\xAE": 1038,
+      "\xAF": 807,
+      "\xB0": 694,
+      "\xB1": 1020,
+      "\xB2": 688,
+      "\xB3": 685,
+      "\xB4": 598,
+      "\xB5": 1126,
+      "\xB6": 1200,
+      "\xB7": 517,
+      "\xB8": 629,
+      "\xB9": 504,
+      "\xBA": 865,
+      "\xBB": 1049,
+      "\xBC": 1303,
+      "\xBD": 1375,
+      "\xBE": 1383,
+      "\xBF": 949,
+      "\xC0": 1185,
+      "\xC1": 1185,
+      "\xC2": 1185,
+      "\xC3": 1185,
+      "\xC4": 1185,
+      "\xC5": 1185,
+      "\xC6": 1563,
+      "\xC7": 1092,
+      "\xC8": 1e3,
+      "\xC9": 1e3,
+      "\xCA": 1e3,
+      "\xCB": 1e3,
+      "\xCC": 516,
+      "\xCD": 516,
+      "\xCE": 516,
+      "\xCF": 516,
+      "\xD0": 1279,
+      "\xD1": 1322,
+      "\xD2": 1356,
+      "\xD3": 1356,
+      "\xD4": 1356,
+      "\xD5": 1356,
+      "\xD6": 1356,
+      "\xD7": 1020,
+      "\xD8": 1359,
+      "\xD9": 1314,
+      "\xDA": 1314,
+      "\xDB": 1314,
+      "\xDC": 1314,
+      "\xDD": 998,
+      "\xDE": 1058,
+      "\xDF": 1080,
+      "\xE0": 981,
+      "\xE1": 981,
+      "\xE2": 981,
+      "\xE3": 981,
+      "\xE4": 981,
+      "\xE5": 981,
+      "\xE6": 1583,
+      "\xE7": 866,
+      "\xE8": 1019,
+      "\xE9": 1019,
+      "\xEA": 1019,
+      "\xEB": 1019,
+      "\xEC": 470,
+      "\xED": 470,
+      "\xEE": 470,
+      "\xEF": 470,
+      "\xF0": 1076,
+      "\xF1": 1076,
+      "\xF2": 1080,
+      "\xF3": 1080,
+      "\xF4": 1080,
+      "\xF5": 1080,
+      "\xF6": 1080,
+      "\xF7": 1020,
+      "\xF8": 1084,
+      "\xF9": 1076,
+      "\xFA": 1076,
+      "\xFB": 1076,
+      "\xFC": 1076,
+      "\xFD": 927,
+      "\xFE": 1076,
+      "\xFF": 927
+    }
+  },
+  LiberationSans: {
+    unitsPerEm: 2048,
+    ascender: 1854,
+    descender: -434,
+    defaultWidth: 1114,
+    cjkWidth: 2048,
+    widths: {
+      " ": 569,
+      "!": 569,
+      '"': 727,
+      "#": 1139,
+      "$": 1139,
+      "%": 1821,
+      "&": 1366,
+      "'": 391,
+      "(": 682,
+      ")": 682,
+      "*": 797,
+      "+": 1196,
+      ",": 569,
+      "-": 682,
+      ".": 569,
+      "/": 569,
+      "0": 1139,
+      "1": 1139,
+      "2": 1139,
+      "3": 1139,
+      "4": 1139,
+      "5": 1139,
+      "6": 1139,
+      "7": 1139,
+      "8": 1139,
+      "9": 1139,
+      ":": 569,
+      ";": 569,
+      "<": 1196,
+      "=": 1196,
+      ">": 1196,
+      "?": 1139,
+      "@": 2079,
+      "A": 1366,
+      "B": 1366,
+      "C": 1479,
+      "D": 1479,
+      "E": 1366,
+      "F": 1251,
+      "G": 1593,
+      "H": 1479,
+      "I": 569,
+      "J": 1024,
+      "K": 1366,
+      "L": 1139,
+      "M": 1706,
+      "N": 1479,
+      "O": 1593,
+      "P": 1366,
+      "Q": 1593,
+      "R": 1479,
+      "S": 1366,
+      "T": 1251,
+      "U": 1479,
+      "V": 1366,
+      "W": 1933,
+      "X": 1366,
+      "Y": 1366,
+      "Z": 1251,
+      "[": 569,
+      "\\": 569,
+      "]": 569,
+      "^": 961,
+      "_": 1139,
+      "`": 682,
+      "a": 1139,
+      "b": 1139,
+      "c": 1024,
+      "d": 1139,
+      "e": 1139,
+      "f": 569,
+      "g": 1139,
+      "h": 1139,
+      "i": 455,
+      "j": 455,
+      "k": 1024,
+      "l": 455,
+      "m": 1706,
+      "n": 1139,
+      "o": 1139,
+      "p": 1139,
+      "q": 1139,
+      "r": 682,
+      "s": 1024,
+      "t": 569,
+      "u": 1139,
+      "v": 1024,
+      "w": 1479,
+      "x": 1024,
+      "y": 1024,
+      "z": 1024,
+      "{": 684,
+      "|": 532,
+      "}": 684,
+      "~": 1196,
+      "\xA0": 569,
+      "\xA1": 682,
+      "\xA2": 1139,
+      "\xA3": 1139,
+      "\xA4": 1139,
+      "\xA5": 1139,
+      "\xA6": 532,
+      "\xA7": 1139,
+      "\xA8": 682,
+      "\xA9": 1509,
+      "\xAA": 758,
+      "\xAB": 1139,
+      "\xAC": 1196,
+      "\xAD": 682,
+      "\xAE": 1509,
+      "\xAF": 1131,
+      "\xB0": 819,
+      "\xB1": 1124,
+      "\xB2": 682,
+      "\xB3": 682,
+      "\xB4": 682,
+      "\xB5": 1180,
+      "\xB6": 1100,
+      "\xB7": 682,
+      "\xB8": 682,
+      "\xB9": 682,
+      "\xBA": 748,
+      "\xBB": 1139,
+      "\xBC": 1708,
+      "\xBD": 1708,
+      "\xBE": 1708,
+      "\xBF": 1251,
+      "\xC0": 1366,
+      "\xC1": 1366,
+      "\xC2": 1366,
+      "\xC3": 1366,
+      "\xC4": 1366,
+      "\xC5": 1366,
+      "\xC6": 2048,
+      "\xC7": 1479,
+      "\xC8": 1366,
+      "\xC9": 1366,
+      "\xCA": 1366,
+      "\xCB": 1366,
+      "\xCC": 569,
+      "\xCD": 569,
+      "\xCE": 569,
+      "\xCF": 569,
+      "\xD0": 1479,
+      "\xD1": 1479,
+      "\xD2": 1593,
+      "\xD3": 1593,
+      "\xD4": 1593,
+      "\xD5": 1593,
+      "\xD6": 1593,
+      "\xD7": 1196,
+      "\xD8": 1593,
+      "\xD9": 1479,
+      "\xDA": 1479,
+      "\xDB": 1479,
+      "\xDC": 1479,
+      "\xDD": 1366,
+      "\xDE": 1366,
+      "\xDF": 1251,
+      "\xE0": 1139,
+      "\xE1": 1139,
+      "\xE2": 1139,
+      "\xE3": 1139,
+      "\xE4": 1139,
+      "\xE5": 1139,
+      "\xE6": 1821,
+      "\xE7": 1024,
+      "\xE8": 1139,
+      "\xE9": 1139,
+      "\xEA": 1139,
+      "\xEB": 1139,
+      "\xEC": 569,
+      "\xED": 569,
+      "\xEE": 569,
+      "\xEF": 569,
+      "\xF0": 1139,
+      "\xF1": 1139,
+      "\xF2": 1139,
+      "\xF3": 1139,
+      "\xF4": 1139,
+      "\xF5": 1139,
+      "\xF6": 1139,
+      "\xF7": 1124,
+      "\xF8": 1251,
+      "\xF9": 1139,
+      "\xFA": 1139,
+      "\xFB": 1139,
+      "\xFC": 1139,
+      "\xFD": 1024,
+      "\xFE": 1139,
+      "\xFF": 1024
+    }
+  },
+  LiberationSerif: {
+    unitsPerEm: 2048,
+    ascender: 1825,
+    descender: -443,
+    defaultWidth: 1056,
+    cjkWidth: 2048,
+    widths: {
+      " ": 512,
+      "!": 682,
+      '"': 836,
+      "#": 1024,
+      "$": 1024,
+      "%": 1706,
+      "&": 1593,
+      "'": 369,
+      "(": 682,
+      ")": 682,
+      "*": 1024,
+      "+": 1155,
+      ",": 512,
+      "-": 682,
+      ".": 512,
+      "/": 569,
+      "0": 1024,
+      "1": 1024,
+      "2": 1024,
+      "3": 1024,
+      "4": 1024,
+      "5": 1024,
+      "6": 1024,
+      "7": 1024,
+      "8": 1024,
+      "9": 1024,
+      ":": 569,
+      ";": 569,
+      "<": 1155,
+      "=": 1155,
+      ">": 1155,
+      "?": 909,
+      "@": 1886,
+      "A": 1479,
+      "B": 1366,
+      "C": 1366,
+      "D": 1479,
+      "E": 1251,
+      "F": 1139,
+      "G": 1479,
+      "H": 1479,
+      "I": 682,
+      "J": 797,
+      "K": 1479,
+      "L": 1251,
+      "M": 1821,
+      "N": 1479,
+      "O": 1479,
+      "P": 1139,
+      "Q": 1479,
+      "R": 1366,
+      "S": 1139,
+      "T": 1251,
+      "U": 1479,
+      "V": 1479,
+      "W": 1933,
+      "X": 1479,
+      "Y": 1479,
+      "Z": 1251,
+      "[": 682,
+      "\\": 569,
+      "]": 682,
+      "^": 961,
+      "_": 1024,
+      "`": 682,
+      "a": 909,
+      "b": 1024,
+      "c": 909,
+      "d": 1024,
+      "e": 909,
+      "f": 682,
+      "g": 1024,
+      "h": 1024,
+      "i": 569,
+      "j": 569,
+      "k": 1024,
+      "l": 569,
+      "m": 1593,
+      "n": 1024,
+      "o": 1024,
+      "p": 1024,
+      "q": 1024,
+      "r": 682,
+      "s": 797,
+      "t": 569,
+      "u": 1024,
+      "v": 1024,
+      "w": 1479,
+      "x": 1024,
+      "y": 1024,
+      "z": 909,
+      "{": 983,
+      "|": 410,
+      "}": 983,
+      "~": 1108,
+      "\xA0": 512,
+      "\xA1": 682,
+      "\xA2": 1024,
+      "\xA3": 1024,
+      "\xA4": 1024,
+      "\xA5": 1024,
+      "\xA6": 410,
+      "\xA7": 1024,
+      "\xA8": 682,
+      "\xA9": 1556,
+      "\xAA": 565,
+      "\xAB": 1024,
+      "\xAC": 1155,
+      "\xAD": 682,
+      "\xAE": 1556,
+      "\xAF": 1024,
+      "\xB0": 819,
+      "\xB1": 1124,
+      "\xB2": 614,
+      "\xB3": 614,
+      "\xB4": 682,
+      "\xB5": 1180,
+      "\xB6": 928,
+      "\xB7": 682,
+      "\xB8": 682,
+      "\xB9": 614,
+      "\xBA": 635,
+      "\xBB": 1024,
+      "\xBC": 1536,
+      "\xBD": 1536,
+      "\xBE": 1536,
+      "\xBF": 909,
+      "\xC0": 1479,
+      "\xC1": 1479,
+      "\xC2": 1479,
+      "\xC3": 1479,
+      "\xC4": 1479,
+      "\xC5": 1479,
+      "\xC6": 1821,
+      "\xC7": 1366,
+      "\xC8": 1251,
+      "\xC9": 1251,
+      "\xCA": 1251,
+      "\xCB": 1251,
+      "\xCC": 682,
+      "\xCD": 682,
+      "\xCE": 682,
+      "\xCF": 682,
+      "\xD0": 1479,
+      "\xD1": 1479,
+      "\xD2": 1479,
+      "\xD3": 1479,
+      "\xD4": 1479,
+      "\xD5": 1479,
+      "\xD6": 1479,
+      "\xD7": 1155,
+      "\xD8": 1479,
+      "\xD9": 1479,
+      "\xDA": 1479,
+      "\xDB": 1479,
+      "\xDC": 1479,
+      "\xDD": 1479,
+      "\xDE": 1139,
+      "\xDF": 1024,
+      "\xE0": 909,
+      "\xE1": 909,
+      "\xE2": 909,
+      "\xE3": 909,
+      "\xE4": 909,
+      "\xE5": 909,
+      "\xE6": 1366,
+      "\xE7": 909,
+      "\xE8": 909,
+      "\xE9": 909,
+      "\xEA": 909,
+      "\xEB": 909,
+      "\xEC": 569,
+      "\xED": 569,
+      "\xEE": 569,
+      "\xEF": 569,
+      "\xF0": 1024,
+      "\xF1": 1024,
+      "\xF2": 1024,
+      "\xF3": 1024,
+      "\xF4": 1024,
+      "\xF5": 1024,
+      "\xF6": 1024,
+      "\xF7": 1124,
+      "\xF8": 1024,
+      "\xF9": 1024,
+      "\xFA": 1024,
+      "\xFB": 1024,
+      "\xFC": 1024,
+      "\xFD": 1024,
+      "\xFE": 1024,
+      "\xFF": 1024
+    }
+  },
+  NotoSansJP: {
+    unitsPerEm: 1e3,
+    ascender: 1160,
+    descender: -288,
+    defaultWidth: 563,
+    cjkWidth: 1e3,
+    widths: {
+      " ": 224,
+      "!": 323,
+      '"': 474,
+      "#": 555,
+      "$": 555,
+      "%": 921,
+      "&": 680,
+      "'": 278,
+      "(": 338,
+      ")": 338,
+      "*": 467,
+      "+": 555,
+      ",": 278,
+      "-": 347,
+      ".": 278,
+      "/": 392,
+      "0": 555,
+      "1": 555,
+      "2": 555,
+      "3": 555,
+      "4": 555,
+      "5": 555,
+      "6": 555,
+      "7": 555,
+      "8": 555,
+      "9": 555,
+      ":": 278,
+      ";": 278,
+      "<": 555,
+      "=": 555,
+      ">": 555,
+      "?": 474,
+      "@": 946,
+      "A": 608,
+      "B": 657,
+      "C": 638,
+      "D": 688,
+      "E": 589,
+      "F": 552,
+      "G": 689,
+      "H": 728,
+      "I": 293,
+      "J": 535,
+      "K": 646,
+      "L": 543,
+      "M": 812,
+      "N": 723,
+      "O": 742,
+      "P": 633,
+      "Q": 742,
+      "R": 635,
+      "S": 596,
+      "T": 599,
+      "U": 721,
+      "V": 575,
+      "W": 878,
+      "X": 573,
+      "Y": 531,
+      "Z": 603,
+      "[": 338,
+      "\\": 392,
+      "]": 338,
+      "^": 555,
+      "_": 559,
+      "`": 606,
+      "a": 563,
+      "b": 618,
+      "c": 510,
+      "d": 620,
+      "e": 554,
+      "f": 325,
+      "g": 564,
+      "h": 607,
+      "i": 275,
+      "j": 275,
+      "k": 552,
+      "l": 284,
+      "m": 926,
+      "n": 610,
+      "o": 606,
+      "p": 620,
+      "q": 620,
+      "r": 388,
+      "s": 468,
+      "t": 377,
+      "u": 607,
+      "v": 521,
+      "w": 802,
+      "x": 498,
+      "y": 521,
+      "z": 475,
+      "{": 338,
+      "|": 270,
+      "}": 338,
+      "~": 555,
+      "\xA0": 224,
+      "\xA1": 323,
+      "\xA2": 555,
+      "\xA3": 555,
+      "\xA4": 555,
+      "\xA5": 555,
+      "\xA6": 270,
+      "\xA7": 1e3,
+      "\xA8": 606,
+      "\xA9": 832,
+      "\xAA": 386,
+      "\xAB": 479,
+      "\xAC": 555,
+      "\xAD": 347,
+      "\xAE": 473,
+      "\xAF": 606,
+      "\xB0": 370,
+      "\xB1": 1e3,
+      "\xB2": 411,
+      "\xB3": 411,
+      "\xB4": 606,
+      "\xB5": 628,
+      "\xB6": 1e3,
+      "\xB7": 561,
+      "\xB8": 606,
+      "\xB9": 411,
+      "\xBA": 407,
+      "\xBB": 479,
+      "\xBC": 873,
+      "\xBD": 903,
+      "\xBE": 889,
+      "\xBF": 474,
+      "\xC0": 608,
+      "\xC1": 608,
+      "\xC2": 608,
+      "\xC3": 608,
+      "\xC4": 608,
+      "\xC5": 608,
+      "\xC6": 918,
+      "\xC7": 638,
+      "\xC8": 589,
+      "\xC9": 589,
+      "\xCA": 589,
+      "\xCB": 589,
+      "\xCC": 293,
+      "\xCD": 293,
+      "\xCE": 293,
+      "\xCF": 293,
+      "\xD0": 712,
+      "\xD1": 723,
+      "\xD2": 742,
+      "\xD3": 742,
+      "\xD4": 742,
+      "\xD5": 742,
+      "\xD6": 742,
+      "\xD7": 1e3,
+      "\xD8": 742,
+      "\xD9": 721,
+      "\xDA": 721,
+      "\xDB": 721,
+      "\xDC": 721,
+      "\xDD": 531,
+      "\xDE": 652,
+      "\xDF": 643,
+      "\xE0": 563,
+      "\xE1": 563,
+      "\xE2": 563,
+      "\xE3": 563,
+      "\xE4": 563,
+      "\xE5": 563,
+      "\xE6": 877,
+      "\xE7": 510,
+      "\xE8": 554,
+      "\xE9": 554,
+      "\xEA": 554,
+      "\xEB": 554,
+      "\xEC": 275,
+      "\xED": 275,
+      "\xEE": 275,
+      "\xEF": 275,
+      "\xF0": 608,
+      "\xF1": 610,
+      "\xF2": 606,
+      "\xF3": 606,
+      "\xF4": 606,
+      "\xF5": 606,
+      "\xF6": 606,
+      "\xF7": 1e3,
+      "\xF8": 606,
+      "\xF9": 607,
+      "\xFA": 607,
+      "\xFB": 607,
+      "\xFC": 607,
+      "\xFD": 521,
+      "\xFE": 620,
+      "\xFF": 521
+    }
+  }
+};
+var fontNameMap = {
+  // Calibri -> Carlito
+  Calibri: "Carlito",
+  calibri: "Carlito",
+  // Arial / Helvetica -> Liberation Sans
+  Arial: "LiberationSans",
+  arial: "LiberationSans",
+  Helvetica: "LiberationSans",
+  helvetica: "LiberationSans",
+  // Times New Roman -> Liberation Serif
+  "Times New Roman": "LiberationSerif",
+  "times new roman": "LiberationSerif",
+  // Japanese fonts -> Noto Sans JP
+  "MS PGothic": "NotoSansJP",
+  "MS P\u30B4\u30B7\u30C3\u30AF": "NotoSansJP",
+  "MS Gothic": "NotoSansJP",
+  "MS \u30B4\u30B7\u30C3\u30AF": "NotoSansJP",
+  Meiryo: "NotoSansJP",
+  \u30E1\u30A4\u30EA\u30AA: "NotoSansJP",
+  "Yu Gothic": "NotoSansJP",
+  \u6E38\u30B4\u30B7\u30C3\u30AF: "NotoSansJP",
+  "Yu Mincho": "NotoSansJP",
+  \u6E38\u660E\u671D: "NotoSansJP",
+  "Hiragino Sans": "NotoSansJP",
+  "Hiragino Kaku Gothic ProN": "NotoSansJP",
+  "Noto Sans JP": "NotoSansJP",
+  "Noto Sans CJK JP": "NotoSansJP"
+};
+var metricsKeyToFontName = {
+  Carlito: "Carlito",
+  LiberationSans: "Liberation Sans",
+  LiberationSerif: "Liberation Serif",
+  NotoSansJP: "Noto Sans JP"
+};
+function getFontMetrics(fontFamily) {
+  if (!fontFamily) return null;
+  const key = fontNameMap[fontFamily] ?? fontNameMap[fontFamily.toLowerCase()];
+  if (!key) return null;
+  return metricsData[key] ?? null;
+}
+function getMetricsFallbackFont(fontFamily) {
+  if (!fontFamily) return null;
+  const key = fontNameMap[fontFamily] ?? fontNameMap[fontFamily.toLowerCase()];
+  if (!key) return null;
+  return metricsKeyToFontName[key] ?? null;
+}
+
+// ../renderer/src/utils/text-measure.ts
+var WIDTH_RATIO = {
+  narrow: 0.3,
+  // i, l, 1, punctuation, etc.
+  normal: 0.6,
+  // average width of latin letters
+  wide: 1
+  // CJK characters (full-width)
+};
+var BOLD_FACTOR = 1.05;
+var PX_PER_PT = 96 / 72;
+var DEFAULT_LINE_HEIGHT_RATIO = 1.2;
+var DEFAULT_ASCENDER_RATIO = 1;
+function getLineHeightRatio(fontFamily, fontFamilyEa) {
+  const metrics = getFontMetrics(fontFamily) ?? getFontMetrics(fontFamilyEa);
+  if (!metrics) return DEFAULT_LINE_HEIGHT_RATIO;
+  return (metrics.ascender + Math.abs(metrics.descender)) / metrics.unitsPerEm;
+}
+function getAscenderRatio(fontFamily, fontFamilyEa) {
+  const metrics = getFontMetrics(fontFamily) ?? getFontMetrics(fontFamilyEa);
+  if (!metrics) return DEFAULT_ASCENDER_RATIO;
+  return metrics.ascender / metrics.unitsPerEm;
+}
+function isCjkCodePoint(codePoint) {
+  return codePoint >= 12288 && codePoint <= 40959 || // CJK symbols, hiragana, katakana, integrated kanji
+  codePoint >= 63744 && codePoint <= 64255 || // CJK compatible kanji
+  codePoint >= 65281 && codePoint <= 65376 || // Full-width alphanumeric characters/symbols
+  codePoint >= 131072 && codePoint <= 173791;
+}
+function categorizeChar(codePoint) {
+  if (isCjkCodePoint(codePoint)) {
+    return "wide";
+  }
+  if (codePoint === 32 || // space
+  codePoint === 33 || // !
+  codePoint === 44 || // ,
+  codePoint === 46 || // .
+  codePoint === 58 || // :
+  codePoint === 59 || // ;
+  codePoint === 105 || // i
+  codePoint === 106 || // j
+  codePoint === 108 || // l
+  codePoint === 49 || // 1
+  codePoint === 124 || // |
+  codePoint === 39 || // '
+  codePoint === 40 || // (
+  codePoint === 41 || // )
+  codePoint === 91 || // [
+  codePoint === 93 || // ]
+  codePoint === 123 || // {
+  codePoint === 125) {
+    return "narrow";
+  }
+  return "normal";
+}
+function measureCharHeuristic(codePoint, baseSizePx) {
+  return baseSizePx * WIDTH_RATIO[categorizeChar(codePoint)];
+}
+function measureCharMetrics(char, codePoint, baseSizePx, metrics) {
+  const charWidth = metrics.widths[char];
+  if (charWidth !== void 0) {
+    return charWidth / metrics.unitsPerEm * baseSizePx;
+  }
+  if (isCjkCodePoint(codePoint)) {
+    return metrics.cjkWidth / metrics.unitsPerEm * baseSizePx;
+  }
+  return metrics.defaultWidth / metrics.unitsPerEm * baseSizePx;
+}
+function measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
+  const baseSizePx = fontSizePt * PX_PER_PT;
+  const latinMetrics = getFontMetrics(fontFamily);
+  const eaMetrics = getFontMetrics(fontFamilyEa);
+  let totalWidth = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    const isEa = isCjkCodePoint(codePoint);
+    const metrics = isEa && eaMetrics ? eaMetrics : latinMetrics;
+    let charWidth;
+    if (metrics) {
+      charWidth = measureCharMetrics(char, codePoint, baseSizePx, metrics);
+    } else {
+      charWidth = measureCharHeuristic(codePoint, baseSizePx);
+    }
+    if (bold && !isEa) {
+      charWidth *= BOLD_FACTOR;
+    }
+    totalWidth += charWidth;
+  }
+  return totalWidth;
+}
+
+// ../renderer/src/font/cjk-font-fallback.ts
+var MACOS_FALLBACKS = {
+  // Gothic family
+  "Noto Sans JP": ["Hiragino Sans", "Hiragino Kaku Gothic ProN"],
+  "Noto Sans CJK JP": ["Hiragino Sans", "Hiragino Kaku Gothic ProN"],
+  // Mincho family
+  "Noto Serif CJK JP": ["Hiragino Mincho ProN"]
+};
+var WINDOWS_FALLBACKS = {
+  // Gothic family
+  "Noto Sans JP": ["Yu Gothic", "Meiryo", "MS Gothic"],
+  "Noto Sans CJK JP": ["Yu Gothic", "Meiryo", "MS Gothic"],
+  // Mincho family
+  "Noto Serif CJK JP": ["Yu Mincho", "MS Mincho"]
+};
+var EMPTY = [];
+var cachedFallbacks = null;
+var platformOverrideForTest = null;
+function getRuntimePlatform() {
+  if (platformOverrideForTest !== null) return platformOverrideForTest;
+  return typeof process !== "undefined" ? process.platform : "";
+}
+function getFallbackMap() {
+  if (cachedFallbacks) return cachedFallbacks;
+  const os = getRuntimePlatform();
+  if (os === "darwin") {
+    cachedFallbacks = MACOS_FALLBACKS;
+  } else if (os === "win32") {
+    cachedFallbacks = WINDOWS_FALLBACKS;
+  } else {
+    cachedFallbacks = {};
+  }
+  return cachedFallbacks;
+}
+function getCjkFallbackFonts(mappedFontName) {
+  return getFallbackMap()[mappedFontName] ?? EMPTY;
+}
+
+// ../renderer/src/font/font-mapping-context.ts
+var currentMapping = { ...DEFAULT_FONT_MAPPING };
+function setFontMapping(mapping) {
+  currentMapping = mapping;
+}
+function resetFontMapping() {
+  currentMapping = { ...DEFAULT_FONT_MAPPING };
+}
+function getCurrentMappedFont(fontFamily) {
+  return getMappedFont(fontFamily, currentMapping);
+}
+
+// ../renderer/src/font/opentype-text-measurer.ts
+var PX_PER_PT2 = 96 / 72;
+var BOLD_FACTOR2 = 1.05;
+var OpentypeTextMeasurer = class {
+  fonts;
+  defaultFont;
+  warnedFonts = /* @__PURE__ */ new Set();
+  /**
+   * @param fonts - font name -> opentype.js Map of Font objects
+   * @param defaultFont - fallback font (optional)
+   */
+  constructor(fonts, defaultFont) {
+    this.fonts = fonts;
+    this.defaultFont = defaultFont ?? null;
+  }
+  measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa) {
+    const latinFont = this.resolveFont(fontFamily);
+    const eaFont = this.resolveFont(fontFamilyEa);
+    const fallbackFont = latinFont ?? eaFont ?? this.defaultFont;
+    if (!fallbackFont) {
+      return measureTextWidth(text, fontSizePt, bold, fontFamily, fontFamilyEa);
+    }
+    const fontSizePx = fontSizePt * PX_PER_PT2;
+    const latinFontResolved = latinFont ?? fallbackFont;
+    const eaFontResolved = eaFont ?? fallbackFont;
+    const boldLatinFont = bold ? this.resolveBoldFont(fontFamily) : null;
+    const latinGlyphCache = /* @__PURE__ */ new Map();
+    const eaGlyphCache = eaFontResolved !== latinFontResolved ? /* @__PURE__ */ new Map() : latinGlyphCache;
+    const boldGlyphCache = /* @__PURE__ */ new Map();
+    let totalWidth = 0;
+    for (const char of text) {
+      const codePoint = char.codePointAt(0);
+      const isEa = isCjkCodePoint(codePoint);
+      const font = isEa ? eaFontResolved : latinFontResolved;
+      const cache = isEa ? eaGlyphCache : latinGlyphCache;
+      if (!cache.has(char)) {
+        cache.set(char, font.stringToGlyphs(char)[0]);
+      }
+      const scale = fontSizePx / font.unitsPerEm;
+      const glyph = cache.get(char);
+      let charWidth = (glyph?.advanceWidth ?? font.unitsPerEm * 0.6) * scale;
+      if (bold && !isEa) {
+        if (boldLatinFont) {
+          if (!boldGlyphCache.has(char)) {
+            boldGlyphCache.set(char, boldLatinFont.stringToGlyphs(char)[0]);
+          }
+          const boldGlyph = boldGlyphCache.get(char);
+          const boldScale = fontSizePx / boldLatinFont.unitsPerEm;
+          charWidth = (boldGlyph?.advanceWidth ?? boldLatinFont.unitsPerEm * 0.6) * boldScale;
+        } else {
+          charWidth *= BOLD_FACTOR2;
+        }
+      }
+      totalWidth += charWidth;
+    }
+    return totalWidth;
+  }
+  getLineHeightRatio(fontFamily, fontFamilyEa) {
+    const font = this.resolveFont(fontFamily) ?? this.resolveFont(fontFamilyEa) ?? this.defaultFont;
+    if (!font) return 1.2;
+    return (font.ascender + Math.abs(font.descender)) / font.unitsPerEm;
+  }
+  getAscenderRatio(fontFamily, fontFamilyEa) {
+    const font = this.resolveFont(fontFamily) ?? this.resolveFont(fontFamilyEa) ?? this.defaultFont;
+    if (!font) return 1;
+    return font.ascender / font.unitsPerEm;
+  }
+  resolveBoldFont(name) {
+    if (!name) return null;
+    const bases = [name];
+    const mappedBase = getCurrentMappedFont(name);
+    if (mappedBase && mappedBase !== name) bases.push(mappedBase);
+    for (const base of bases) {
+      for (const boldName of [`${base} Bold`, `${base}-Bold`]) {
+        const direct = this.fonts.get(boldName);
+        if (direct) return direct;
+        const mapped = getCurrentMappedFont(boldName);
+        if (mapped) {
+          const mappedFont = this.fonts.get(mapped);
+          if (mappedFont) return mappedFont;
+        }
+      }
+    }
+    return null;
+  }
+  resolveFont(name) {
+    if (!name) return null;
+    const direct = this.fonts.get(name);
+    if (direct) return direct;
+    const mapped = getCurrentMappedFont(name);
+    if (mapped) {
+      const mappedFont = this.fonts.get(mapped);
+      if (mappedFont) return mappedFont;
+      for (const fallback of getCjkFallbackFonts(mapped)) {
+        const fallbackFont = this.fonts.get(fallback);
+        if (fallbackFont) return fallbackFont;
+      }
+    }
+    if (!this.warnedFonts.has(name)) {
+      this.warnedFonts.add(name);
+      warn("font.notFound", `Font not found: "${name}"`);
+    }
+    return null;
+  }
+};
+
+// ../renderer/src/font/text-path-context.ts
+var DefaultTextPathFontResolver = class {
+  fonts;
+  defaultFont;
+  warnedFonts = /* @__PURE__ */ new Set();
+  constructor(fonts, defaultFont) {
+    this.fonts = fonts;
+    this.defaultFont = defaultFont ?? null;
+  }
+  resolveFont(fontFamily, fontFamilyEa, jpanFallback) {
+    if (fontFamily) {
+      const font = this.findFont(fontFamily);
+      if (font) return font;
+    }
+    if (fontFamilyEa) {
+      const font = this.findFont(fontFamilyEa);
+      if (font) return font;
+    }
+    if (jpanFallback) {
+      const font = this.findFont(jpanFallback);
+      if (font) return font;
+    }
+    for (const name of [fontFamily, fontFamilyEa, jpanFallback]) {
+      if (name && !this.warnedFonts.has(name)) {
+        this.warnedFonts.add(name);
+        warn("font.notFound", `Font not found: "${name}"`);
+      }
+    }
+    return this.defaultFont;
+  }
+  findFont(name) {
+    const direct = this.fonts.get(name);
+    if (direct) return direct;
+    const mapped = getCurrentMappedFont(name);
+    if (mapped) {
+      const mappedFont = this.fonts.get(mapped);
+      if (mappedFont) return mappedFont;
+      for (const fallback of getCjkFallbackFonts(mapped)) {
+        const fallbackFont = this.fonts.get(fallback);
+        if (fallbackFont) return fallbackFont;
+      }
+    }
+    return null;
+  }
+};
+var currentResolver = null;
+function setTextPathFontResolver(resolver) {
+  currentResolver = resolver;
+}
+function getTextPathFontResolver() {
+  return currentResolver;
+}
+function resetTextPathFontResolver() {
+  currentResolver = null;
+}
+
+// ../renderer/src/font/ttc-parser.ts
+var TTC_TAG = 1953784678;
+function isTtcBuffer(data) {
+  const view = toDataView(data);
+  if (view.byteLength < 4) return false;
+  return view.getUint32(0) === TTC_TAG;
+}
+function extractTtcFonts(data) {
+  const view = toDataView(data);
+  const bytes = toUint8Array(data);
+  if (view.byteLength < 12) return [];
+  if (view.getUint32(0) !== TTC_TAG) return [];
+  const numFonts = view.getUint32(8);
+  if (numFonts === 0) return [];
+  const headerEnd = 12 + numFonts * 4;
+  if (view.byteLength < headerEnd) return [];
+  const results = [];
+  for (let i = 0; i < numFonts; i++) {
+    try {
+      const fontOffset = view.getUint32(12 + i * 4);
+      const extracted = extractSingleFont(view, bytes, fontOffset);
+      if (extracted) results.push(extracted);
+    } catch {
+    }
+  }
+  return results;
+}
+function extractSingleFont(view, bytes, fontOffset) {
+  if (fontOffset + 12 > view.byteLength) return null;
+  const sfVersion = view.getUint32(fontOffset);
+  const numTables = view.getUint16(fontOffset + 4);
+  if (numTables === 0) return null;
+  const tableRecordsStart = fontOffset + 12;
+  const tableRecordsEnd = tableRecordsStart + numTables * 16;
+  if (tableRecordsEnd > view.byteLength) return null;
+  const tables = [];
+  for (let i = 0; i < numTables; i++) {
+    const recOffset = tableRecordsStart + i * 16;
+    const tableOffset = view.getUint32(recOffset + 8);
+    const tableLength = view.getUint32(recOffset + 12);
+    if (tableOffset > view.byteLength || tableLength > view.byteLength - tableOffset) {
+      return null;
+    }
+    tables.push({
+      tag: view.getUint32(recOffset),
+      checkSum: view.getUint32(recOffset + 4),
+      offset: tableOffset,
+      length: tableLength
+    });
+  }
+  const headerSize = 12 + numTables * 16;
+  let dataSize = 0;
+  for (const table of tables) {
+    dataSize += alignTo4(table.length);
+  }
+  const totalSize = headerSize + dataSize;
+  const output = new ArrayBuffer(totalSize);
+  const outView = new DataView(output);
+  const outBytes = new Uint8Array(output);
+  outView.setUint32(0, sfVersion);
+  outView.setUint16(4, numTables);
+  const { searchRange, entrySelector, rangeShift } = calcOffsetTableFields(numTables);
+  outView.setUint16(6, searchRange);
+  outView.setUint16(8, entrySelector);
+  outView.setUint16(10, rangeShift);
+  let currentDataOffset = headerSize;
+  for (let i = 0; i < numTables; i++) {
+    const table = tables[i];
+    const recOffset = 12 + i * 16;
+    outView.setUint32(recOffset, table.tag);
+    outView.setUint32(recOffset + 4, table.checkSum);
+    outView.setUint32(recOffset + 8, currentDataOffset);
+    outView.setUint32(recOffset + 12, table.length);
+    outBytes.set(bytes.subarray(table.offset, table.offset + table.length), currentDataOffset);
+    currentDataOffset += alignTo4(table.length);
+  }
+  return output;
+}
+function alignTo4(n) {
+  return n + 3 & ~3;
+}
+function calcOffsetTableFields(numTables) {
+  let searchRange = 16;
+  let entrySelector = 0;
+  while (searchRange * 2 <= numTables * 16) {
+    searchRange *= 2;
+    entrySelector++;
+  }
+  const rangeShift = numTables * 16 - searchRange;
+  return { searchRange, entrySelector, rangeShift };
+}
+function toDataView(data) {
+  if (data instanceof Uint8Array) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return new DataView(data);
+}
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  return new Uint8Array(data);
+}
+
+// ../renderer/src/font/opentype-buffer-helpers.ts
+async function tryLoadOpentype() {
+  try {
+    const mod = await import("opentype.js");
+    return {
+      parse: (buffer) => unsafeExternalInteropAssertion(mod.parse(buffer))
+    };
+  } catch {
+    return null;
+  }
+}
+function buildReverseMapping(mapping) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [pptxName, ossName] of Object.entries(mapping)) {
+    const existing = reverse.get(ossName) ?? [];
+    existing.push(pptxName);
+    reverse.set(ossName, existing);
+  }
+  return reverse;
+}
+function toArrayBuffer(data) {
+  if (data instanceof ArrayBuffer) return data;
+  return unsafeExternalInteropAssertion(
+    data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)
+  );
+}
+function parseFontBuffer(arrayBuffer, opentype) {
+  if (isTtcBuffer(arrayBuffer)) {
+    const fonts = extractTtcFonts(arrayBuffer);
+    if (fonts.length > 0) {
+      try {
+        return [opentype.parse(fonts[0])];
+      } catch {
+      }
+    }
+    return [];
+  }
+  return [opentype.parse(arrayBuffer)];
+}
+function createOpentypeSetupState() {
+  return {
+    measurerFonts: /* @__PURE__ */ new Map(),
+    resolverFonts: /* @__PURE__ */ new Map(),
+    firstMeasurerFont: null,
+    firstResolverFont: null
+  };
+}
+function registerParsedFont(font, reverseMap, state, explicitName) {
+  if (!state.firstMeasurerFont) state.firstMeasurerFont = font;
+  if (!state.firstResolverFont)
+    state.firstResolverFont = unsafeExternalInteropAssertion(font);
+  if (explicitName) {
+    registerFont(explicitName, font, reverseMap, state.measurerFonts, state.resolverFonts);
+  }
+  for (const name of collectFontNames(font)) {
+    registerFont(name, font, reverseMap, state.measurerFonts, state.resolverFonts);
+  }
+}
+function registerFont(name, font, reverseMap, measurerFonts, resolverFonts) {
+  const fullFont = unsafeExternalInteropAssertion(font);
+  if (!measurerFonts.has(name)) {
+    measurerFonts.set(name, font);
+    resolverFonts.set(name, fullFont);
+  }
+  const pptxNames = reverseMap.get(name);
+  if (pptxNames) {
+    for (const pptxName of pptxNames) {
+      if (!measurerFonts.has(pptxName)) {
+        measurerFonts.set(pptxName, font);
+        resolverFonts.set(pptxName, fullFont);
+      }
+    }
+  }
+}
+function collectFontNames(font) {
+  const names = /* @__PURE__ */ new Set();
+  if (font.names.fontFamily) {
+    for (const name of Object.values(font.names.fontFamily)) {
+      names.add(name);
+    }
+  }
+  if (font.names.preferredFamily) {
+    for (const name of Object.values(font.names.preferredFamily)) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function buildOpentypeSetupFromState(state) {
+  if (state.measurerFonts.size === 0 && !state.firstMeasurerFont) return null;
+  const measurer = new OpentypeTextMeasurer(
+    state.measurerFonts,
+    state.firstMeasurerFont ?? void 0
+  );
+  const fontResolver = new DefaultTextPathFontResolver(
+    state.resolverFonts,
+    state.firstResolverFont ?? void 0
+  );
+  return { measurer, fontResolver };
+}
+async function createOpentypeTextMeasurerFromBuffers(fontBuffers, fontMapping) {
+  const setup = await createOpentypeSetupFromBuffers(fontBuffers, fontMapping);
+  return setup?.measurer ?? null;
+}
+async function createOpentypeSetupFromBuffers(fontBuffers, fontMapping) {
+  if (fontBuffers.length === 0) return null;
+  const opentype = await tryLoadOpentype();
+  if (!opentype) return null;
+  const mapping = createFontMapping(fontMapping);
+  const reverseMap = buildReverseMapping(mapping);
+  const state = createOpentypeSetupState();
+  for (const buffer of fontBuffers) {
+    try {
+      const arrayBuffer = toArrayBuffer(buffer.data);
+      const fonts = parseFontBuffer(arrayBuffer, opentype);
+      for (const font of fonts) {
+        registerParsedFont(font, reverseMap, state, buffer.name);
+      }
+    } catch {
+    }
+  }
+  return buildOpentypeSetupFromState(state);
+}
+var SYSTEM_FONT_CACHE_KEY = "__pptxGlimpseSystemFontCache__";
+function getSystemFontCacheStore() {
+  const globalObject = globalThis;
+  globalObject[SYSTEM_FONT_CACHE_KEY] ??= { setup: null, key: null };
+  return globalObject[SYSTEM_FONT_CACHE_KEY];
+}
+function getCachedSystemOpentypeSetup(key) {
+  const cache = getSystemFontCacheStore();
+  return cache.key === key ? cache.setup : void 0;
+}
+function setCachedSystemOpentypeSetup(key, setup) {
+  const cache = getSystemFontCacheStore();
+  cache.setup = setup;
+  cache.key = key;
+}
+function clearFontCache() {
+  const cache = getSystemFontCacheStore();
+  cache.setup = null;
+  cache.key = null;
+}
+
+export {
+  getMetricsFallbackFont,
+  unsafeExternalInteropAssertion,
+  unsafeBrandAssertion,
+  initWarningLogger,
+  warn,
+  debug,
+  getWarningSummary,
+  flushWarnings,
+  getWarningEntries,
+  DEFAULT_FONT_MAPPING,
+  createFontMapping,
+  getMappedFont,
+  setFontMapping,
+  resetFontMapping,
+  getCurrentMappedFont,
+  getLineHeightRatio,
+  getAscenderRatio,
+  measureTextWidth,
+  setTextPathFontResolver,
+  getTextPathFontResolver,
+  resetTextPathFontResolver,
+  tryLoadOpentype,
+  buildReverseMapping,
+  toArrayBuffer,
+  parseFontBuffer,
+  createOpentypeSetupState,
+  registerParsedFont,
+  buildOpentypeSetupFromState,
+  createOpentypeTextMeasurerFromBuffers,
+  createOpentypeSetupFromBuffers,
+  getCachedSystemOpentypeSetup,
+  setCachedSystemOpentypeSetup,
+  clearFontCache
+};