ooxml-ui 1.28.1 → 1.29.0

package/dist/pptx/{chunk-34A7YWVZ.cjs → chunk-BXCXY4HB.cjs}

@@ -1,36 +1,35 @@
 'use strict';
 
+var chunkXOAXPD2W_cjs = require('./chunk-XOAXPD2W.cjs');
+var chunkW3X2UVYQ_cjs = require('./chunk-W3X2UVYQ.cjs');
 var chunkWSTWYZFM_cjs = require('./chunk-WSTWYZFM.cjs');
 var chunkX7FS7XHU_cjs = require('./chunk-X7FS7XHU.cjs');
 var chunkXFQ2RD4I_cjs = require('./chunk-XFQ2RD4I.cjs');
 var chunk52LKIMK3_cjs = require('./chunk-52LKIMK3.cjs');
 var chunkH5IPNKX6_cjs = require('./chunk-H5IPNKX6.cjs');
-var chunkXOAXPD2W_cjs = require('./chunk-XOAXPD2W.cjs');
 var chunkBSGCZ4JZ_cjs = require('./chunk-BSGCZ4JZ.cjs');
 var chunkIOOI63TH_cjs = require('./chunk-IOOI63TH.cjs');
 var chunkZJFN5POF_cjs = require('./chunk-ZJFN5POF.cjs');
 var chunkCWWL7MCL_cjs = require('./chunk-CWWL7MCL.cjs');
 var chunkWB25PCHQ_cjs = require('./chunk-WB25PCHQ.cjs');
-var chunkW3X2UVYQ_cjs = require('./chunk-W3X2UVYQ.cjs');
+var chunkUSBRSEJK_cjs = require('./chunk-USBRSEJK.cjs');
 var chunk6KLPQQYP_cjs = require('./chunk-6KLPQQYP.cjs');
 var chunkFOE75Z6N_cjs = require('./chunk-FOE75Z6N.cjs');
 var chunkNTXHQHCS_cjs = require('./chunk-NTXHQHCS.cjs');
-var chunkFM4C4MBJ_cjs = require('./chunk-FM4C4MBJ.cjs');
-var chunkYMITEJST_cjs = require('./chunk-YMITEJST.cjs');
+var chunk67UQWOEQ_cjs = require('./chunk-67UQWOEQ.cjs');
+var chunk3CYWRMYZ_cjs = require('./chunk-3CYWRMYZ.cjs');
+var chunkEW5DW5KR_cjs = require('./chunk-EW5DW5KR.cjs');
 var chunkUPN5FFKP_cjs = require('./chunk-UPN5FFKP.cjs');
 var chunkOJFD3SHS_cjs = require('./chunk-OJFD3SHS.cjs');
-var chunkUSBRSEJK_cjs = require('./chunk-USBRSEJK.cjs');
 var chunk3ESFHUZI_cjs = require('./chunk-3ESFHUZI.cjs');
 var chunkU47LRWDT_cjs = require('./chunk-U47LRWDT.cjs');
-var chunkGWKTHP6U_cjs = require('./chunk-GWKTHP6U.cjs');
+var chunkPATUICO4_cjs = require('./chunk-PATUICO4.cjs');
 var chunkY6DO6SVT_cjs = require('./chunk-Y6DO6SVT.cjs');
 var chunkPBZWDEXQ_cjs = require('./chunk-PBZWDEXQ.cjs');
-var chunkEW5DW5KR_cjs = require('./chunk-EW5DW5KR.cjs');
 var pptx = require('ooxml-core/pptx');
 var color = require('ooxml-core/color');
 var text$1 = require('ooxml-core/text');
 var textSegmentParagraphBreak = require('ooxml-core/pptx/editor/render/text-segment-paragraph-break');
-var opentypeModule = require('opentype.js');
 var math = require('ooxml-core/math');
 var chart = require('ooxml-core/chart');
 var schemaLabelKeys = require('ooxml-core/pptx/editor/render/schema-label-keys');
@@ -96,26 +95,6 @@ var live_js = require('lit/directives/live.js');
 var drawingml = require('ooxml-core/drawingml');
 var keyed_js = require('lit/directives/keyed.js');
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var opentypeModule__namespace = /*#__PURE__*/_interopNamespace(opentypeModule);
-
 // src/pptx/web-components/control-styles.ts
 var sheetsByDocument = /* @__PURE__ */ new WeakMap();
 function attachControlStyles(root, css) {
@@ -1660,10 +1639,10 @@ function getComputedStrokeStyle(element) {
   const borderColor = style.strokeOpacity === void 0 ? rawColor : chunk6KLPQQYP_cjs.colorWithOpacity(chunk6KLPQQYP_cjs.normalizeHexColor(rawColor, chunk6KLPQQYP_cjs.DEFAULT_STROKE_COLOR), style.strokeOpacity);
   return {
     borderWidth,
-    cssBorderWidth: chunkFM4C4MBJ_cjs.screenStrokeWidth(borderWidth),
+    cssBorderWidth: chunk67UQWOEQ_cjs.screenStrokeWidth(borderWidth),
     borderStyle,
     borderColor,
-    border: chunkFM4C4MBJ_cjs.screenBorder(borderWidth, borderStyle ?? "solid", borderColor),
+    border: chunk67UQWOEQ_cjs.screenBorder(borderWidth, borderStyle ?? "solid", borderColor),
     ...joins
   };
 }
@@ -1883,12 +1862,12 @@ function getPresetShapeVectorGeometry(shapeType, width, height, adjustments) {
 function outlineStrands(compoundLine, strokeWidth) {
   const offsets2 = getCompoundLineOffsets(compoundLine, strokeWidth);
   if (offsets2.length <= 1) {
-    return [{ strokeWidth, cssStrokeWidth: chunkFM4C4MBJ_cjs.screenStrokeWidth(strokeWidth), offset: 0 }];
+    return [{ strokeWidth, cssStrokeWidth: chunk67UQWOEQ_cjs.screenStrokeWidth(strokeWidth), offset: 0 }];
   }
   const widths = getCompoundLineWidths(compoundLine, strokeWidth);
   return offsets2.map((offset, idx) => {
     const width = widths[idx] ?? strokeWidth;
-    return { strokeWidth: width, cssStrokeWidth: chunkFM4C4MBJ_cjs.screenStrokeWidth(width), offset };
+    return { strokeWidth: width, cssStrokeWidth: chunk67UQWOEQ_cjs.screenStrokeWidth(width), offset };
   });
 }
 function needsCenteredStrokeOverlay(element, style, declaredWidth) {
@@ -1914,7 +1893,7 @@ function clipEdgeBleed(element, d, style) {
   return edge ? {
     d: edge,
     strokeWidth: 1,
-    cssStrokeWidth: `max(1px, calc(2 * var(${chunkFM4C4MBJ_cjs.DEVICE_PX_VAR}, 0px)))`,
+    cssStrokeWidth: `max(1px, calc(2 * var(${chunk67UQWOEQ_cjs.DEVICE_PX_VAR}, 0px)))`,
     offset: 0
   } : void 0;
 }
@@ -7478,6 +7457,43 @@ function readFontFileStyle(bytes) {
   };
 }
 var trustedByList = /* @__PURE__ */ new WeakMap();
+var typefaceTrustByList = /* @__PURE__ */ new WeakMap();
+function trimmedName(font) {
+  return typeof font.name === "string" ? font.name.trim() : "";
+}
+function isEmbeddedTypefaceTrusted(fonts, typeface) {
+  const name = typeface.trim();
+  let memo = typefaceTrustByList.get(fonts);
+  const known = memo?.get(name);
+  if (known !== void 0) {
+    return known;
+  }
+  let trusted = true;
+  if (name && resolveGoogleFontsFace(name)) {
+    for (const font of fonts) {
+      if (trimmedName(font) !== name) {
+        continue;
+      }
+      const bytes = resolveEmbeddedFontClearBytes(font);
+      const actual = bytes ? readFontFileStyle(bytes) : void 0;
+      if (!actual) {
+        continue;
+      }
+      const expectedWeight = resolveFontWeight(name, Boolean(font.bold));
+      const expectedItalic = resolveFontItalic(name, font.italic);
+      if (Math.abs(actual.weight - expectedWeight) >= WEIGHT_TOLERANCE || actual.italic !== expectedItalic) {
+        trusted = false;
+        break;
+      }
+    }
+  }
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    typefaceTrustByList.set(fonts, memo);
+  }
+  memo.set(name, trusted);
+  return trusted;
+}
 function selectTrustedEmbeddedFonts(fonts) {
   if (!fonts || fonts.length === 0) {
     return [];
@@ -7486,30 +7502,147 @@ function selectTrustedEmbeddedFonts(fonts) {
   if (memo) {
     return memo;
   }
-  const rejected = /* @__PURE__ */ new Set();
-  for (const font of fonts) {
-    const name = typeof font.name === "string" ? font.name.trim() : "";
-    if (!name || rejected.has(name) || !resolveGoogleFontsFace(name)) {
-      continue;
+  const trusted = fonts.filter((font) => isEmbeddedTypefaceTrusted(fonts, trimmedName(font)));
+  trustedByList.set(fonts, trusted);
+  return trusted;
+}
+
+// src/pptx/render/glyph-outline-font-registration.ts
+var EmbeddedFontCandidates = class {
+  byKey = /* @__PURE__ */ new Map();
+  /** Weak, so a list that is no longer referenced by any candidate is not kept here. */
+  registrations = /* @__PURE__ */ new WeakMap();
+  /**
+   * Record each font of `list` under `keyOf(font)`, after the candidates
+   * already recorded for that key. `keyOf` returns `undefined` for a font
+   * that needs no record. A list that is already registered is left as it is,
+   * so its fonts keep their place, and gains one more owner. Returns this
+   * owner's release: the candidates `list` has here are removed once every
+   * owner has released. Calling a release again does nothing, and a release
+   * from before the list was fully released never touches a later
+   * registration of the same list.
+   */
+  add(list, keyOf) {
+    let registration = this.registrations.get(list);
+    if (!registration) {
+      registration = { keys: /* @__PURE__ */ new Set(), owners: 0 };
+      this.registrations.set(list, registration);
+      for (const font of list) {
+        const key = keyOf(font);
+        if (key === void 0) {
+          continue;
+        }
+        registration.keys.add(key);
+        const candidates = this.byKey.get(key);
+        if (candidates) {
+          candidates.push({ font, list });
+        } else {
+          this.byKey.set(key, [{ font, list }]);
+        }
+      }
     }
-    const bytes = resolveEmbeddedFontClearBytes(font);
-    const actual = bytes ? readFontFileStyle(bytes) : void 0;
-    if (!actual) {
-      continue;
+    registration.owners += 1;
+    const owned = registration;
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      this.release(list, owned);
+    };
+  }
+  /** Whether any candidate is recorded for `key`. */
+  has(key) {
+    return this.byKey.has(key);
+  }
+  /** The keys that have candidates recorded. */
+  keys() {
+    return this.byKey.keys();
+  }
+  /** Remove and return the candidates recorded for `key`, in registration order. */
+  take(key) {
+    const candidates = this.byKey.get(key);
+    this.byKey.delete(key);
+    return candidates;
+  }
+  /** Every candidate still recorded, key by key in registration order. */
+  *[Symbol.iterator]() {
+    for (const candidates of this.byKey.values()) {
+      yield* candidates;
     }
-    const expectedWeight = resolveFontWeight(name, Boolean(font.bold));
-    const expectedItalic = resolveFontItalic(name, font.italic);
-    if (Math.abs(actual.weight - expectedWeight) >= WEIGHT_TOLERANCE || actual.italic !== expectedItalic) {
-      rejected.add(name);
+  }
+  release(list, registration) {
+    if (this.registrations.get(list) !== registration) {
+      return;
+    }
+    registration.owners -= 1;
+    if (registration.owners > 0) {
+      return;
+    }
+    this.registrations.delete(list);
+    for (const key of registration.keys) {
+      const candidates = this.byKey.get(key);
+      if (!candidates) {
+        continue;
+      }
+      const kept = candidates.filter((candidate) => candidate.list !== list);
+      if (kept.length > 0) {
+        this.byKey.set(key, kept);
+      } else {
+        this.byKey.delete(key);
+      }
     }
   }
-  const trusted = rejected.size === 0 ? [...fonts] : fonts.filter(
-    (font) => !rejected.has(typeof font.name === "string" ? font.name.trim() : "")
-  );
-  trustedByList.set(fonts, trusted);
-  return trusted;
+};
+function createEmbeddedOutlineFontsSlot(cache) {
+  let current;
+  let releaseCurrent;
+  const release = () => {
+    const releasing = releaseCurrent;
+    current = void 0;
+    releaseCurrent = void 0;
+    releasing?.();
+  };
+  return {
+    set(fonts) {
+      if (fonts && fonts === current) {
+        return;
+      }
+      release();
+      if (!fonts || fonts.length === 0) {
+        return;
+      }
+      current = fonts;
+      releaseCurrent = cache.registerEmbeddedFonts(fonts);
+    },
+    release
+  };
 }
-function parseOpenTypeFont(buffer, module = opentypeModule__namespace) {
+
+// src/pptx/render/text-warp-opentype-parser.ts
+var loadedModule;
+var loading;
+function isOpenTypeFontParserReady() {
+  return loadedModule !== void 0;
+}
+function preloadOpenTypeFontParser() {
+  loading ??= import('opentype.js').then((module) => {
+    const resolved2 = module;
+    if (!resolved2.parse && !resolved2.default?.parse) {
+      throw new Error("opentype.js does not expose a font parser");
+    }
+    loadedModule = resolved2;
+  }).catch((error) => {
+    loading = void 0;
+    throw error;
+  });
+  return loading;
+}
+function parseOpenTypeFont(buffer, module = loadedModule) {
+  if (!module) {
+    throw new Error("opentype.js is not loaded yet; await preloadOpenTypeFontParser() first");
+  }
   const parser = module.parse ?? module.default?.parse;
   if (!parser) {
     throw new Error("opentype.js does not expose a font parser");
@@ -7517,6 +7650,55 @@ function parseOpenTypeFont(buffer, module = opentypeModule__namespace) {
   return parser(buffer);
 }
 
+// src/pptx/render/text-warp-glyph-outline-lookup.ts
+var WHITESPACE_RE2 = /^\s$/u;
+function extractGlyphOutlineCommands(font, char, x, y, fontSizePx) {
+  if (!char) {
+    return void 0;
+  }
+  if (WHITESPACE_RE2.test(char)) {
+    return [];
+  }
+  try {
+    if (!font.hasChar(char)) {
+      return void 0;
+    }
+    const path = font.getPath(char, x, y, fontSizePx);
+    return path.commands.map((cmd) => {
+      switch (cmd.type) {
+        case "M":
+        case "L":
+          return { type: cmd.type, x: cmd.x, y: cmd.y };
+        case "Q":
+          return { type: "Q", x1: cmd.x1, y1: cmd.y1, x: cmd.x, y: cmd.y };
+        case "C":
+          return { type: "C", x1: cmd.x1, y1: cmd.y1, x2: cmd.x2, y2: cmd.y2, x: cmd.x, y: cmd.y };
+        case "Z":
+        default:
+          return { type: "Z" };
+      }
+    });
+  } catch {
+    return void 0;
+  }
+}
+function createGlyphOutlineLookup(cache) {
+  return (char, font, x, y) => {
+    if (WHITESPACE_RE2.test(char)) {
+      return [];
+    }
+    const parsed = cache.get(font.fontFamily, font.bold, font.italic);
+    if (parsed) {
+      const size2 = font.fontSizePx && font.fontSizePx > 0 ? font.fontSizePx : chunk6KLPQQYP_cjs.DEFAULT_TEXT_FONT_SIZE;
+      const commands = extractGlyphOutlineCommands(parsed, char, x, y, size2);
+      if (commands) {
+        return commands;
+      }
+    }
+    return traceGlyphOutlineCommands(char, font, x, y);
+  };
+}
+
 // src/pptx/render/text-warp-outline-font-cache.ts
 function toArrayBuffer(bytes) {
   const copy = bytes.slice();
@@ -7526,114 +7708,284 @@ function primaryFontFamily(family2) {
   const first = family2.split(",")[0] ?? family2;
   return first.trim().replace(/^['"]|['"]$/gu, "");
 }
+function sameBytes(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
 function cacheKey(family2, bold, italic) {
   return `${primaryFontFamily(family2).toLowerCase()}|${bold ? 1 : 0}|${italic ? 1 : 0}`;
 }
 var GlyphOutlineFontCache = class {
   fonts = /* @__PURE__ */ new Map();
   attempted = /* @__PURE__ */ new Set();
-  /** The parsed font for `(family, bold, italic)`, or `undefined` if unavailable. */
+  /**
+   * Registered embedded candidates per key, in registration order and grouped
+   * by deck, with nothing read from them yet. A key's embedded candidates are
+   * always older than its {@link pendingBytes}: an embedded font is not
+   * recorded for a key that already has bytes, as it would not have been
+   * parsed on arrival.
+   */
+  pendingEmbedded = new EmbeddedFontCandidates();
+  /**
+   * Webfont bytes registered before the parser loaded, oldest first. Every
+   * candidate is kept until one parses: a later registration only replaces an
+   * earlier one if it parses, exactly as when each is parsed on arrival.
+   */
+  pendingBytes = /* @__PURE__ */ new Map();
+  /** Keys a lookup missed: parsing one later changes what a repaint draws. */
+  missed = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  notifyQueued = false;
+  loading;
+  /**
+   * Call `listener` when a newly parsed font makes an outline available that
+   * an earlier lookup could not use. Returns the unsubscribe function. Shaped
+   * for `useSyncExternalStore`.
+   */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** A number that changes each time {@link subscribe} listeners are notified. */
+  getSnapshot = () => this.revision;
+  /**
+   * Load the parser if needed and parse every waiting font, embedded ones
+   * included, so later lookups resolve synchronously. Await it before a
+   * render that must use font-file outlines on its first pass. Rejects if the
+   * parser cannot be loaded; the waiting fonts are kept, so a later call
+   * retries. The load a lookup starts on its own parses only the fonts that
+   * lookups asked for, so other embedded fonts stay undecoded.
+   */
+  preload() {
+    if (isOpenTypeFontParserReady()) {
+      this.resolveAllPending();
+      return Promise.resolve();
+    }
+    return this.loadParser().then(() => {
+      this.resolveAllPending();
+    });
+  }
+  /**
+   * The parsed font for `(family, bold, italic)`, or `undefined` if unavailable.
+   * Missing a font whose candidates wait for the parser starts loading it.
+   */
   get(family2, bold, italic) {
     if (!family2) {
       return void 0;
     }
-    return this.fonts.get(cacheKey(family2, Boolean(bold), Boolean(italic)));
+    const key = cacheKey(family2, Boolean(bold), Boolean(italic));
+    const font = this.fonts.get(key);
+    if (font) {
+      return font;
+    }
+    const waiting = this.hasPending(key);
+    if (waiting && isOpenTypeFontParserReady()) {
+      this.resolvePending(key);
+      return this.fonts.get(key);
+    }
+    this.missed.add(key);
+    if (waiting) {
+      this.requestParser();
+    }
+    return void 0;
   }
-  /** True once this `(family, bold, italic)` has been looked up, whether or not it resolved. */
+  /**
+   * True once a parse of this `(family, bold, italic)` was attempted, whether
+   * or not it resolved. With the parser loaded this settles the key's waiting
+   * candidates first, like a lookup; before that they are not attempts yet.
+   */
   hasAttempted(family2, bold, italic) {
-    return this.attempted.has(cacheKey(family2, bold, italic));
+    const key = cacheKey(family2, bold, italic);
+    if (isOpenTypeFontParserReady()) {
+      this.resolvePending(key);
+    }
+    return this.attempted.has(key);
   }
   /**
-   * Synchronously parse every embedded font whose bytes are already
-   * resolvable, no network involved. Safe to call repeatedly (e.g. once per
-   * render) with the same list: already-resolved or already-failed entries
-   * are skipped. Typefaces whose files do not match them are skipped too
-   * (see `selectTrustedEmbeddedFonts`), exactly as for `@font-face`.
+   * Record every embedded font for outline lookups, no network involved and
+   * nothing decoded yet. Safe to call repeatedly (e.g. once per render) with
+   * the same list: a list already registered is not recorded again, and
+   * already-resolved or already-failed entries are skipped. Typefaces whose
+   * files do not match them are skipped too (see
+   * `isEmbeddedTypefaceTrusted`), exactly as for `@font-face`. A font for a
+   * key a lookup already missed is parsed now if the parser is loaded, and
+   * otherwise starts loading it.
+   *
+   * Returns the release for this deck: call it when the deck is closed or
+   * replaced to drop its fonts that were never looked up, so the cache stops
+   * holding them. Fonts already parsed stay cached, as before.
    */
   registerEmbeddedFonts(fonts) {
-    for (const font of selectTrustedEmbeddedFonts(fonts)) {
+    let needed = false;
+    const release = this.pendingEmbedded.add(fonts, (font) => {
       if (!font.name) {
-        continue;
+        return void 0;
       }
       const key = cacheKey(font.name, Boolean(font.bold), Boolean(font.italic));
-      if (this.fonts.has(key) || this.attempted.has(key)) {
-        continue;
-      }
-      this.attempted.add(key);
-      const bytes = resolveEmbeddedFontClearBytes(font);
-      if (!bytes || bytes.length < 4) {
-        continue;
-      }
-      try {
-        this.fonts.set(key, parseOpenTypeFont(toArrayBuffer(bytes)));
-      } catch {
+      if (this.fonts.has(key) || this.attempted.has(key) || this.pendingBytes.has(key)) {
+        return void 0;
       }
+      needed ||= this.missed.has(key);
+      return key;
+    });
+    if (needed) {
+      this.resolveMissedOrLoad();
     }
+    return release;
   }
   /**
    * Register raw bytes fetched separately for `(family, bold, italic)` (see
    * `text-warp-outline-webfont-fetch.ts`). Returns whether parsing
    * succeeded; a caller that owns re-rendering can use this to know whether
-   * a re-render is worth triggering.
+   * a re-render is worth triggering. Before the parser is loaded the bytes
+   * are kept and `false` is returned; {@link subscribe} listeners are told
+   * if they later fill in an outline that a lookup already asked for. Either
+   * way, bytes that do not parse leave the font already registered for this
+   * key (or still waiting for the parser) in place.
    */
   registerFontBytes(family2, bold, italic, bytes) {
     const key = cacheKey(family2, bold, italic);
-    this.attempted.add(key);
     if (bytes.length < 4) {
+      this.attempted.add(key);
+      return false;
+    }
+    if (!isOpenTypeFontParserReady()) {
+      this.addPendingBytes(key, bytes);
+      if (this.missed.has(key)) {
+        this.requestParser();
+      }
       return false;
     }
+    if (this.parseInto(key, bytes)) {
+      this.dropPending(key);
+      return true;
+    }
+    this.resolvePending(key);
+    return false;
+  }
+  /** Parse `bytes` for `key`; on failure the font already set for `key` stays. */
+  parseInto(key, bytes) {
+    this.attempted.add(key);
     try {
       this.fonts.set(key, parseOpenTypeFont(toArrayBuffer(bytes)));
-      return true;
     } catch {
       return false;
     }
+    if (this.missed.delete(key)) {
+      this.notify();
+    }
+    return true;
   }
-};
-var WHITESPACE_RE2 = /^\s$/u;
-function extractGlyphOutlineCommands(font, char, x, y, fontSizePx) {
-  if (!char) {
-    return void 0;
+  addPendingBytes(key, bytes) {
+    const waiting = this.pendingBytes.get(key) ?? [];
+    const index = waiting.findIndex((candidate) => sameBytes(candidate, bytes));
+    if (index >= 0) {
+      waiting.splice(index, 1);
+    }
+    waiting.push(bytes);
+    this.pendingBytes.set(key, waiting);
   }
-  if (WHITESPACE_RE2.test(char)) {
-    return [];
+  hasPending(key) {
+    return this.pendingBytes.has(key) || this.pendingEmbedded.has(key);
   }
-  try {
-    if (!font.hasChar(char)) {
-      return void 0;
+  dropPending(key) {
+    this.pendingBytes.delete(key);
+    this.pendingEmbedded.take(key);
+  }
+  /**
+   * Resolve the candidates waiting for `key` as if each had been parsed on
+   * arrival (the parser must be loaded): the newest bytes that parse win, and
+   * only when none do is the key's first trusted embedded font, the one an
+   * eager registration would have parsed, decoded and parsed. Untrusted
+   * embedded candidates are passed over without marking the key attempted.
+   */
+  resolvePending(key) {
+    const bytes = this.pendingBytes.get(key);
+    this.pendingBytes.delete(key);
+    const embedded = this.pendingEmbedded.take(key);
+    if (bytes) {
+      for (let i = bytes.length - 1; i >= 0; i -= 1) {
+        if (this.parseInto(key, bytes[i])) {
+          return;
+        }
+      }
     }
-    const path = font.getPath(char, x, y, fontSizePx);
-    return path.commands.map((cmd) => {
-      switch (cmd.type) {
-        case "M":
-        case "L":
-          return { type: cmd.type, x: cmd.x, y: cmd.y };
-        case "Q":
-          return { type: "Q", x1: cmd.x1, y1: cmd.y1, x: cmd.x, y: cmd.y };
-        case "C":
-          return { type: "C", x1: cmd.x1, y1: cmd.y1, x2: cmd.x2, y2: cmd.y2, x: cmd.x, y: cmd.y };
-        case "Z":
-        default:
-          return { type: "Z" };
+    for (const { font, list } of embedded ?? []) {
+      if (!isEmbeddedTypefaceTrusted(list, font.name)) {
+        continue;
       }
-    });
-  } catch {
-    return void 0;
+      this.attempted.add(key);
+      const clear = resolveEmbeddedFontClearBytes(font);
+      if (clear && clear.length >= 4) {
+        this.parseInto(key, clear);
+      }
+      return;
+    }
   }
-}
-function createGlyphOutlineLookup(cache) {
-  return (char, font, x, y) => {
-    const parsed = cache.get(font.fontFamily, font.bold, font.italic);
-    if (parsed) {
-      const size2 = font.fontSizePx && font.fontSizePx > 0 ? font.fontSizePx : chunk6KLPQQYP_cjs.DEFAULT_TEXT_FONT_SIZE;
-      const commands = extractGlyphOutlineCommands(parsed, char, x, y, size2);
-      if (commands) {
-        return commands;
+  resolveAllPending() {
+    for (const key of /* @__PURE__ */ new Set([...this.pendingBytes.keys(), ...this.pendingEmbedded.keys()])) {
+      this.resolvePending(key);
+    }
+  }
+  /** Parse the waiting candidates of the keys lookups missed, the only ones a repaint needs. */
+  resolveMissed() {
+    for (const key of [...this.missed]) {
+      if (this.hasPending(key)) {
+        this.resolvePending(key);
       }
     }
-    return WHITESPACE_RE2.test(char) ? [] : traceGlyphOutlineCommands(char, font, x, y);
-  };
-}
+  }
+  resolveMissedOrLoad() {
+    if (isOpenTypeFontParserReady()) {
+      this.resolveMissed();
+    } else {
+      this.requestParser();
+    }
+  }
+  loadParser() {
+    this.loading ??= preloadOpenTypeFontParser().then(
+      () => {
+        this.loading = void 0;
+        this.resolveMissed();
+      },
+      (error) => {
+        this.loading = void 0;
+        throw error;
+      }
+    );
+    return this.loading;
+  }
+  /** Coalesce notifications, and never call listeners from inside a caller's own update. */
+  notify() {
+    if (this.notifyQueued) {
+      return;
+    }
+    this.notifyQueued = true;
+    queueMicrotask(() => {
+      this.notifyQueued = false;
+      this.revision += 1;
+      for (const listener of [...this.listeners]) {
+        listener();
+      }
+    });
+  }
+  requestParser() {
+    this.loadParser().catch(() => void 0);
+  }
+};
 
 // src/pptx/render/google-webfonts-metric-clones.ts
 var METRIC_COMPATIBLE_CLONES = {
@@ -7799,7 +8151,7 @@ var EQUATION_TEMPLATES = [
 
 // src/pptx/render/mathml-sanitize.ts
 function sanitizeMathMl(markup) {
-  const sanitized = chunkYMITEJST_cjs.sanitizeMarkupOrEmpty(markup, { USE_PROFILES: { mathMl: true, svg: true } });
+  const sanitized = chunk3CYWRMYZ_cjs.sanitizeMarkupOrEmpty(markup, { USE_PROFILES: { mathMl: true, svg: true } });
   if (/<math(?:\s|>)/iu.test(markup) && !/<math(?:\s|>)/iu.test(sanitized) && sanitized) {
     return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${sanitized}</math>`;
   }
@@ -22291,7 +22643,7 @@ function borderToCss(border, resolve) {
   const width = border.width ?? 1;
   const dash = ooxmlDashToCssBorderStyle(border.dash);
   const color = border.color ?? resolve(border.fill) ?? "#000000";
-  return chunkFM4C4MBJ_cjs.screenBorder(width, dash, color);
+  return chunk67UQWOEQ_cjs.screenBorder(width, dash, color);
 }
 function collectSections(entry6, tableData, pos) {
   const { rowIndex, cellIndex, rowCount, columnCount } = pos;
@@ -23756,7 +24108,7 @@ function cellStyleToCss(style) {
       const w = edge.width ?? 1;
       const c = edge.color ?? style.borderColor ?? "#000000";
       const s = ooxmlDashToCssBorderStyle(edge.dash);
-      css[edge.prefix] = chunkFM4C4MBJ_cjs.screenBorder(w, s, c);
+      css[edge.prefix] = chunk67UQWOEQ_cjs.screenBorder(w, s, c);
     }
   }
   Object.assign(css, cellPaddingCss(style));
@@ -27449,7 +27801,7 @@ function createTemplateContext(options = {}) {
   const scheme = { ...pptx.DEFAULT_SCHEME_COLOR_MAP, ...options.scheme ?? {} };
   let counter = 0;
   const idFor = options.idFor ?? ((index) => `template-el-${Date.now()}-${index}`);
-  const dictionary = chunkGWKTHP6U_cjs.translationsEn;
+  const dictionary = chunkPATUICO4_cjs.translationsEn;
   const translate = options.translate ?? ((key) => dictionary[key] ?? key);
   return {
     scheme,
@@ -45372,6 +45724,42 @@ function syncGoogleWebfontStylesheet(doc, id, href) {
   }
   return link;
 }
+var LOAD_LIMIT_MESSAGE_KEYS = Object.freeze({
+  maxInputBytes: "pptx.viewer.loadLimit.maxInputBytes",
+  maxUncompressedBytes: "pptx.viewer.loadLimit.maxUncompressedBytes",
+  maxEntries: "pptx.viewer.loadLimit.maxEntries",
+  maxSlides: "pptx.viewer.loadLimit.maxSlides",
+  maxShapes: "pptx.viewer.loadLimit.maxShapes"
+});
+var BYTE_LIMITS = /* @__PURE__ */ new Set([
+  "maxInputBytes",
+  "maxUncompressedBytes"
+]);
+function formatLoadLimitBytes(bytes) {
+  if (bytes < 1024) {
+    return `${Math.round(bytes)} B`;
+  }
+  const kib = bytes / 1024;
+  if (kib < 1024) {
+    return `${Math.round(kib * 10) / 10} KB`;
+  }
+  return `${Math.round(kib / 1024 * 10) / 10} MB`;
+}
+function formatValue(limit, value) {
+  return BYTE_LIMITS.has(limit) ? formatLoadLimitBytes(value) : String(Math.round(value));
+}
+function pptxLoadErrorMessage(error, t2) {
+  const violation = pptx.getPptxLoadLimitViolation(error);
+  if (violation) {
+    const { limit, maximum } = violation;
+    const actual = violation.actual ?? maximum + 1;
+    return t2(LOAD_LIMIT_MESSAGE_KEYS[limit], {
+      actual: formatValue(limit, actual),
+      maximum: formatValue(limit, maximum)
+    });
+  }
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/pptx/render/custom-shows.ts
 function generateCustomShowId() {
@@ -52075,7 +52463,7 @@ function commentMarkerTitle(comment, fallbackAuthor) {
 }
 function buildCommentMarkers(comments, canvasWidth, canvasHeight, fallbackAuthor) {
   return comments.map((comment, index) => {
-    const pos = chunkYMITEJST_cjs.getCommentMarkerPosition(comment, index, canvasWidth, canvasHeight);
+    const pos = chunk3CYWRMYZ_cjs.getCommentMarkerPosition(comment, index, canvasWidth, canvasHeight);
     return {
       commentId: comment.id,
       label: String(index + 1),
@@ -62880,13 +63268,13 @@ function smartArtColorPatch(data, fillColors) {
 
 // src/pptx/render/smartart-builtin-layouts.ts
 var loaded;
-var loading;
+var loading2;
 function preloadSmartArtBuiltinLayouts() {
-  loading ??= import('ooxml-core/pptx/smartart-layouts').then(
+  loading2 ??= import('ooxml-core/pptx/smartart-layouts').then(
     (module) => loaded = module,
     () => void 0
   );
-  return loading;
+  return loading2;
 }
 function smartArtBuiltinLayouts() {
   if (!loaded) {
@@ -68272,14 +68660,14 @@ async function buildForeignObjectSvgBody(element, doc, options) {
     backgroundColor,
     readComputedStyle = (el) => window.getComputedStyle(el)
   } = options;
-  await chunkFM4C4MBJ_cjs.settleThreeViews(element);
+  await chunk67UQWOEQ_cjs.settleThreeViews(element);
   const clone = element.cloneNode(true);
-  chunkFM4C4MBJ_cjs.withAuthoredStrokeWidths(
+  chunk67UQWOEQ_cjs.withAuthoredStrokeWidths(
     element,
     () => inlineComputedStylesOnClone(element, clone, readComputedStyle)
   );
-  chunkFM4C4MBJ_cjs.snapshotThreeViewsIntoClone(element, clone);
-  chunkFM4C4MBJ_cjs.prepareExportClone(clone);
+  chunk67UQWOEQ_cjs.snapshotThreeViewsIntoClone(element, clone);
+  chunk67UQWOEQ_cjs.prepareExportClone(clone);
   const [{ allEmbedded: imagesEmbedded }, externalFonts] = await Promise.all([
     embedImagesOnClone(clone),
     collectExternalFontFaceCss(doc, fetchAsDataUrl)
@@ -77502,13 +77890,13 @@ function chartSpaceFormatSource(space, options = {}) {
     labelOptions: labels
   };
 }
-var chartFormatLocale = (value) => i18n.normalizeLocale(value, chunkGWKTHP6U_cjs.CHART_FORMAT_LOCALES, "en");
+var chartFormatLocale = (value) => i18n.normalizeLocale(value, chunkPATUICO4_cjs.CHART_FORMAT_LOCALES, "en");
 function chartFormatTranslator(locale, override) {
-  const strings = chunkGWKTHP6U_cjs.CHART_FORMAT_STRINGS[chartFormatLocale(locale)];
+  const strings = chunkPATUICO4_cjs.CHART_FORMAT_STRINGS[chartFormatLocale(locale)];
   return (key, params, fallback) => {
     const own = override?.(key, params, fallback);
     if (own && own !== key) return own;
-    return strings[key] ?? chunkGWKTHP6U_cjs.CHART_FORMAT_STRINGS.en[key] ?? key;
+    return strings[key] ?? chunkPATUICO4_cjs.CHART_FORMAT_STRINGS.en[key] ?? key;
   };
 }
 
@@ -82603,7 +82991,7 @@ function definePptxInsertSmartArtDialog(registry2) {
       if (this.#live || this.#draw) {
         return;
       }
-      this.#live = import('./smartart-insert-preview-OW6RXM7M.cjs').then((module) => {
+      this.#live = import('./smartart-insert-preview-DHQ47GXP.cjs').then((module) => {
         if (this.#draw || !this.#picker) {
           return;
         }
@@ -88737,7 +89125,7 @@ function sanitizeSlideSvg(svg2, width, height) {
   if (!isSafeSvgMarkup(svg2)) {
     return "";
   }
-  const sanitized = chunkYMITEJST_cjs.sanitizeMarkupOrEmpty(svg2, { USE_PROFILES: { svg: true } }).trim();
+  const sanitized = chunk3CYWRMYZ_cjs.sanitizeMarkupOrEmpty(svg2, { USE_PROFILES: { svg: true } }).trim();
   if (!sanitized || sanitized.toLowerCase().startsWith("<svg")) {
     return sanitized;
   }
@@ -89272,18 +89660,18 @@ function definedSettings(settings) {
 }
 function planPrintJob(settings, deck) {
   const slideCount = deck.slides.length;
-  const validated = chunkYMITEJST_cjs.validatePrintSettings(definedSettings(settings), slideCount);
+  const validated = chunk3CYWRMYZ_cjs.validatePrintSettings(definedSettings(settings), slideCount);
   if (!PRINT_WHAT.includes(validated.printWhat) || !SLIDE_RANGES.includes(validated.slideRange)) {
     return { ok: false, reason: "invalid-settings" };
   }
-  const inDeck = chunkYMITEJST_cjs.computeSlideIndices(
+  const inDeck = chunk3CYWRMYZ_cjs.computeSlideIndices(
     validated.slideRange,
     deck.activeSlideIndex,
     slideCount,
     validated.customRangeFrom,
     validated.customRangeTo
   ).filter((index) => Number.isInteger(index) && index >= 0 && index < slideCount);
-  const slideIndices = chunkYMITEJST_cjs.filterHiddenSlideIndices(
+  const slideIndices = chunk3CYWRMYZ_cjs.filterHiddenSlideIndices(
     inDeck,
     deck.slides,
     deck.includeHiddenSlides ?? false
@@ -89325,12 +89713,12 @@ function frameSlideSvg(svg2, width, height) {
   return `${svg2.slice(0, end)}${frame}${svg2.slice(end)}`;
 }
 function buildOutlinePrintJobDocument(plan, title, slides) {
-  const outline = chunkYMITEJST_cjs.buildOutlineHtml([...plan.slideIndices], slides);
-  return chunkYMITEJST_cjs.buildPrintHtmlDocument({
+  const outline = chunk3CYWRMYZ_cjs.buildOutlineHtml([...plan.slideIndices], slides);
+  return chunk3CYWRMYZ_cjs.buildPrintHtmlDocument({
     title,
     bodyHtml: `<div class="outline-page">${outline}</div>`,
     orientation: plan.orientation,
-    colorFilter: chunkYMITEJST_cjs.computeColorFilter(plan.settings.colorMode),
+    colorFilter: chunk3CYWRMYZ_cjs.computeColorFilter(plan.settings.colorMode),
     frameSlides: plan.settings.frameSlides,
     scaleToFit: plan.settings.scaleToFit ?? true
   });
@@ -89340,24 +89728,24 @@ function buildVectorPrintJobDocument(plan, title, svgs, size2) {
   return buildPrintDocument(pages, size2.width, size2.height, {
     title,
     orientation: plan.orientation,
-    colorFilter: chunkYMITEJST_cjs.computeColorFilter(plan.settings.colorMode),
+    colorFilter: chunk3CYWRMYZ_cjs.computeColorFilter(plan.settings.colorMode),
     scaleToFit: plan.settings.scaleToFit ?? true
   });
 }
 function buildRasterPrintJobDocument(plan, title, captures, slides, handoutMaster) {
   const images = captures.map((capture) => capture.dataUrl);
   const indices = captures.map((capture) => capture.slideIndex);
-  let bodyHtml = chunkYMITEJST_cjs.buildSlidesHtml(images, indices);
+  let bodyHtml = chunk3CYWRMYZ_cjs.buildSlidesHtml(images, indices);
   if (plan.printWhat === "notes") {
-    bodyHtml = chunkYMITEJST_cjs.buildNotesHtml(images, indices, slides);
+    bodyHtml = chunk3CYWRMYZ_cjs.buildNotesHtml(images, indices, slides);
   } else if (plan.printWhat === "handouts") {
-    bodyHtml = chunkYMITEJST_cjs.buildHandoutsHtml(images, indices, plan.settings.slidesPerPage, handoutMaster);
+    bodyHtml = chunk3CYWRMYZ_cjs.buildHandoutsHtml(images, indices, plan.settings.slidesPerPage, handoutMaster);
   }
-  return chunkYMITEJST_cjs.buildPrintHtmlDocument({
+  return chunk3CYWRMYZ_cjs.buildPrintHtmlDocument({
     title,
     bodyHtml,
     orientation: plan.orientation,
-    colorFilter: chunkYMITEJST_cjs.computeColorFilter(plan.settings.colorMode),
+    colorFilter: chunk3CYWRMYZ_cjs.computeColorFilter(plan.settings.colorMode),
     frameSlides: plan.settings.frameSlides,
     scaleToFit: plan.settings.scaleToFit ?? true
   });
@@ -91674,6 +92062,7 @@ exports.LINK_TOOLTIP_HOST_CLASS = LINK_TOOLTIP_HOST_CLASS;
 exports.LINK_TOOLTIP_LABEL_CLASS = LINK_TOOLTIP_LABEL_CLASS;
 exports.LINK_TOOLTIP_PANEL_CLASS = LINK_TOOLTIP_PANEL_CLASS;
 exports.LIVE_PATCH_THROTTLE_MS = LIVE_PATCH_THROTTLE_MS;
+exports.LOAD_LIMIT_MESSAGE_KEYS = LOAD_LIMIT_MESSAGE_KEYS;
 exports.LONG_PRESS_DURATION_MS = LONG_PRESS_DURATION_MS;
 exports.LONG_PRESS_MOVE_TOLERANCE_PX = LONG_PRESS_MOVE_TOLERANCE_PX;
 exports.MARKER_SUPPORTED_TYPES = MARKER_SUPPORTED_TYPES;
@@ -92528,6 +92917,7 @@ exports.createDeckStyleHost = createDeckStyleHost;
 exports.createDefaultChartElement = createDefaultChartElement;
 exports.createDefaultChartUserShapeGroupChild = createDefaultChartUserShapeGroupChild;
 exports.createEditorHistoryController = createEditorHistoryController;
+exports.createEmbeddedOutlineFontsSlot = createEmbeddedOutlineFontsSlot;
 exports.createEnvelopeWarp = createEnvelopeWarp;
 exports.createGalleryPreviewController = createGalleryPreviewController;
 exports.createGestureController = createGestureController;
@@ -92776,6 +93166,7 @@ exports.formatCursorLabel = formatCursorLabel;
 exports.formatEditPointsTarget = formatEditPointsTarget;
 exports.formatElapsed = formatElapsed;
 exports.formatIsoDate = formatIsoDate;
+exports.formatLoadLimitBytes = formatLoadLimitBytes;
 exports.formatMediaTime = formatMediaTime;
 exports.formatMobileElapsed = formatMobileElapsed;
 exports.formatRelativeTime = formatRelativeTime;
@@ -93405,6 +93796,7 @@ exports.polygonRegionBounds = polygonRegionBounds;
 exports.powerPointAccelDecelProgress = powerPointAccelDecelProgress;
 exports.pptxChartFormatKey = pptxChartFormatKey;
 exports.pptxChartFormatSource = pptxChartFormatSource;
+exports.pptxLoadErrorMessage = pptxLoadErrorMessage;
 exports.pptxOptionsLabels = pptxOptionsLabels;
 exports.prefersReducedMotion = prefersReducedMotion;
 exports.prepareElementForInsertion = prepareElementForInsertion;