ooxml-ui 1.28.0 → 1.29.0

package/dist/pptx/{chunk-WBFAVFD4.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;
 }
@@ -6873,8 +6852,8 @@ function layoutEnvelopeBlock(paragraphs2, align2, getGlyphOutline) {
         const char = chars[i];
         const advance = advances[i] ?? 0;
         const outline = WHITESPACE_RE.test(char) ? void 0 : getGlyphOutline?.(char, seg.font, x, baseline);
-        const usable = outline && outline.length > 0 ? outline : void 0;
-        const ink = glyphInk(char, seg.font, x, baseline, advance, usable);
+        const usable2 = outline && outline.length > 0 ? outline : void 0;
+        const ink = glyphInk(char, seg.font, x, baseline, advance, usable2);
         if (ink) {
           hasInk = true;
           box.left = Math.min(box.left, ink.left);
@@ -6892,7 +6871,7 @@ function layoutEnvelopeBlock(paragraphs2, align2, getGlyphOutline) {
           x,
           baseline,
           advance,
-          outline: usable,
+          outline: usable2,
           ink
         });
         x += advance;
@@ -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;
+    }
+  }
+  release(list, registration) {
+    if (this.registrations.get(list) !== registration) {
+      return;
+    }
+    registration.owners -= 1;
+    if (registration.owners > 0) {
+      return;
     }
-    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);
+    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
+  };
+}
+
+// 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 = opentypeModule__namespace) {
+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>`;
   }
@@ -7878,9 +8230,9 @@ function computeTrendlinePoints(trendline, values, catCount, layout, range, mode
   };
 }
 function valueToYLocal(val, range, topY, bottomY) {
-  const usable = bottomY - topY;
+  const usable2 = bottomY - topY;
   const ratio = (val - range.min) / range.span;
-  return range.reverseOrder ? topY + ratio * usable : bottomY - ratio * usable;
+  return range.reverseOrder ? topY + ratio * usable2 : bottomY - ratio * usable2;
 }
 
 // src/pptx/render/chart-sparkline.ts
@@ -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() {
@@ -47917,9 +48305,9 @@ function deserializeElementClipboard(text4) {
   try {
     parsed = JSON.parse(text4, (_key, value) => {
       if (typeof value === "object" && value !== null) {
-        const tagged = value[BINARY_TAG];
-        if (typeof tagged === "string") {
-          return base64ToUint8(tagged);
+        const tagged2 = value[BINARY_TAG];
+        if (typeof tagged2 === "string") {
+          return base64ToUint8(tagged2);
         }
       }
       return value;
@@ -51603,6 +51991,153 @@ function applyUniformCellPaddingPatch(el, padding) {
   };
 }
 
+// src/comments/mentions.ts
+var usable = (text4, mentions) => (mentions ?? []).filter(
+  (m) => Number.isFinite(m.start) && Number.isFinite(m.length) && m.length > 0 && m.start >= 0 && m.start + m.length <= text4.length
+).sort((a, b) => a.start - b.start);
+function commentSegments(text4, mentions) {
+  const body = String(text4 ?? "");
+  const segments = [];
+  let cursor = 0;
+  for (const mention of usable(body, mentions)) {
+    if (mention.start < cursor) continue;
+    if (mention.start > cursor)
+      segments.push({ kind: "text", text: body.slice(cursor, mention.start) });
+    segments.push({
+      kind: "mention",
+      text: body.slice(mention.start, mention.start + mention.length),
+      ...mention.id !== void 0 ? { id: mention.id } : {},
+      ...mention.name !== void 0 ? { name: mention.name } : {}
+    });
+    cursor = mention.start + mention.length;
+  }
+  if (cursor < body.length) segments.push({ kind: "text", text: body.slice(cursor) });
+  return segments;
+}
+function mentionQueryAt(text4, caret) {
+  const body = String(text4 ?? "");
+  const end = Math.max(0, Math.min(caret, body.length));
+  for (let index = end - 1; index >= 0; index -= 1) {
+    const character = body[index];
+    if (character === "@") {
+      if (index > 0 && !/\s/u.test(body[index - 1])) return null;
+      return { query: body.slice(index + 1, end).toLowerCase(), start: index };
+    }
+    if (/\s/u.test(character)) return null;
+  }
+  return null;
+}
+var score = (candidate, needle) => {
+  if (!needle) return 1;
+  const name = candidate.name.toLowerCase();
+  if (name.startsWith(needle)) return 0;
+  if (name.includes(needle) || (candidate.initials ?? "").toLowerCase().startsWith(needle))
+    return 2;
+  return -1;
+};
+function matchMentionCandidates(candidates, query, limit = 6) {
+  const needle = String(query ?? "").trim().toLowerCase();
+  return candidates.filter((candidate) => candidate.id && candidate.name).map((candidate) => ({ candidate, rank: score(candidate, needle) })).filter(({ rank }) => rank >= 0).sort((a, b) => a.rank - b.rank || a.candidate.name.localeCompare(b.candidate.name)).slice(0, limit).map(({ candidate }) => candidate);
+}
+function insertMention(text4, mentions, caret, candidate) {
+  const body = String(text4 ?? "");
+  const at = Math.max(0, Math.min(caret, body.length));
+  const active2 = mentionQueryAt(body, at);
+  const start = active2 ? active2.start : at;
+  const end = at;
+  const label3 = `@${candidate.name}`;
+  const delta = label3.length + 1 - (end - start);
+  const next = (mentions ?? []).filter((m) => m.start >= end || m.start + m.length <= start).map((m) => m.start >= end ? { ...m, start: m.start + delta } : m);
+  next.push({ start, length: label3.length, id: candidate.id, name: candidate.name });
+  next.sort((a, b) => a.start - b.start);
+  return {
+    text: `${body.slice(0, start)}${label3} ${body.slice(end)}`,
+    mentions: next,
+    caret: start + label3.length + 1
+  };
+}
+function trimMentionText(text4, mentions) {
+  const body = String(text4 ?? "");
+  const trimmed = body.trim();
+  const lead = trimmed ? body.length - body.trimStart().length : 0;
+  return {
+    text: trimmed,
+    mentions: usable(body, mentions).filter((m) => m.start >= lead && m.start + m.length <= lead + trimmed.length).map((m) => ({ ...m, start: m.start - lead }))
+  };
+}
+
+// src/pptx/render/comment-mentions.ts
+var COMMENT_MENTION_ATTRIBUTE = "data-pptx-comment-mention";
+var COMMENT_MENTION_CLASS = "pptx-comment-mention";
+var toSpan = (mention) => ({
+  start: mention.startIndex,
+  length: mention.length,
+  ...mention.personId !== void 0 ? { id: mention.personId } : {},
+  ...mention.authorName !== void 0 ? { name: mention.authorName } : {}
+});
+function commentTextSegments(text4, mentions) {
+  return commentSegments(text4, mentions?.map(toSpan)).map((segment) => ({
+    kind: segment.kind,
+    text: segment.text,
+    ...segment.name !== void 0 ? { authorName: segment.name } : {},
+    ...segment.id !== void 0 ? { personId: segment.id } : {}
+  }));
+}
+function hasCommentMentions(text4, mentions) {
+  return commentTextSegments(text4, mentions).some((segment) => segment.kind === "mention");
+}
+function commentMentionQuery(text4, caret) {
+  return mentionQueryAt(text4, caret);
+}
+function matchCommentMentionAuthors(authors, query, limit = 6) {
+  return matchMentionCandidates(authors, query, limit);
+}
+function tagged(mentions) {
+  return mentions.map((mention, index) => ({
+    start: mention.startIndex,
+    length: mention.length,
+    id: String(index)
+  }));
+}
+function untagged(spans, records) {
+  return spans.map((span) => ({ ...records[Number(span.id)], startIndex: span.start }));
+}
+function trimCommentMentions(text4, mentions) {
+  const records = mentions ?? [];
+  const result = trimMentionText(text4, tagged(records));
+  return { text: result.text, mentions: untagged(result.mentions, records) };
+}
+function followCommentEdit(before, after, mentions) {
+  return pptx.rebaseCommentMentions(mentions ? [...mentions] : void 0, before, after) ?? [];
+}
+function defaultMentionId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `{${crypto.randomUUID().toUpperCase()}}`;
+  }
+  const hex2 = (length) => Array.from(
+    { length },
+    () => Math.floor(Math.random() * 16).toString(16).toUpperCase()
+  ).join("");
+  return `{${hex2(8)}-${hex2(4)}-4${hex2(3)}-8${hex2(3)}-${hex2(12)}}`;
+}
+function insertCommentMention(text4, mentions, caret, author, generateId = defaultMentionId) {
+  const existing = mentions ?? [];
+  const result = insertMention(text4, tagged(existing), caret, { id: author.id, name: author.name });
+  return {
+    text: result.text,
+    caret: result.caret,
+    mentions: result.mentions.map(
+      (span) => span.name === void 0 ? { ...existing[Number(span.id)], startIndex: span.start } : {
+        id: generateId(),
+        personId: author.id,
+        authorName: author.name,
+        startIndex: span.start,
+        length: span.length
+      }
+    )
+  };
+}
+
 // src/pptx/render/comments-list.ts
 function generateCommentId() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -51611,14 +52146,18 @@ function generateCommentId() {
   const rand = Math.random().toString(36).slice(2);
   return `comment-${Date.now().toString(36)}-${rand}`;
 }
-function addCommentToList(comments, text4, authorName, x, y, elementId) {
-  const trimmed = text4.trim();
-  if (trimmed.length === 0) {
+function bodyWithMentions(text4, mentions) {
+  const body = trimCommentMentions(text4, mentions);
+  return body.mentions.length > 0 ? body : { text: body.text };
+}
+function addCommentToList(comments, text4, authorName, x, y, elementId, mentions) {
+  const body = bodyWithMentions(text4, mentions);
+  if (body.text.length === 0) {
     return null;
   }
   const comment = {
     id: generateCommentId(),
-    text: trimmed,
+    ...body,
     author: authorName,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     resolved: false,
@@ -51670,20 +52209,22 @@ function removeCommentFromList(comments, id) {
   const [next, changed] = filterCommentTree(comments, id);
   return changed ? next : null;
 }
-function editCommentInList(comments, id, text4) {
-  const trimmed = text4.trim();
+function editCommentInList(comments, id, text4, mentions) {
+  const given = mentions ? bodyWithMentions(text4, mentions) : null;
+  const trimmed = given ? given.text : text4.trim();
   if (trimmed.length === 0) {
     return null;
   }
-  const [next, changed] = mapCommentTree(comments, id, (comment) => ({
-    ...comment,
-    text: trimmed
-  }));
+  const [next, changed] = mapCommentTree(comments, id, (comment) => {
+    const { mentions: previous, ...rest } = comment;
+    const kept = given ? given.mentions ?? [] : followCommentEdit(comment.text, trimmed, previous);
+    return { ...rest, text: trimmed, ...kept.length > 0 ? { mentions: kept } : {} };
+  });
   return changed ? next : null;
 }
-function replyToCommentInList(comments, parentId, text4, authorName) {
-  const trimmed = text4.trim();
-  if (trimmed.length === 0) {
+function replyToCommentInList(comments, parentId, text4, authorName, mentions) {
+  const body = bodyWithMentions(text4, mentions);
+  if (body.text.length === 0) {
     return null;
   }
   const parent = comments.find((comment) => comment.id === parentId);
@@ -51692,7 +52233,7 @@ function replyToCommentInList(comments, parentId, text4, authorName) {
   }
   const reply = {
     id: generateCommentId(),
-    text: trimmed,
+    ...body,
     author: authorName,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     threadId: parentId,
@@ -51914,110 +52455,6 @@ function runReviewCommentCommand(id, host2, activeId) {
   }
 }
 
-// src/pptx/render/comment-mentions.ts
-var COMMENT_MENTION_ATTRIBUTE = "data-pptx-comment-mention";
-var COMMENT_MENTION_CLASS = "pptx-comment-mention";
-var usableMentions = (body, mentions) => (mentions ?? []).filter(
-  (mention) => Number.isFinite(mention.startIndex) && Number.isFinite(mention.length) && mention.length > 0 && mention.startIndex >= 0 && mention.startIndex + mention.length <= body.length
-).sort((a, b) => a.startIndex - b.startIndex);
-function commentTextSegments(text4, mentions) {
-  const body = String(text4 ?? "");
-  if (body.length === 0) {
-    return [];
-  }
-  const segments = [];
-  let cursor = 0;
-  for (const mention of usableMentions(body, mentions)) {
-    if (mention.startIndex < cursor) {
-      continue;
-    }
-    if (mention.startIndex > cursor) {
-      segments.push({ kind: "text", text: body.slice(cursor, mention.startIndex) });
-    }
-    segments.push({
-      kind: "mention",
-      text: body.slice(mention.startIndex, mention.startIndex + mention.length),
-      authorName: mention.authorName,
-      personId: mention.personId
-    });
-    cursor = mention.startIndex + mention.length;
-  }
-  if (cursor < body.length) {
-    segments.push({ kind: "text", text: body.slice(cursor) });
-  }
-  return segments;
-}
-function hasCommentMentions(text4, mentions) {
-  return commentTextSegments(text4, mentions).some((segment) => segment.kind === "mention");
-}
-function commentMentionQuery(text4, caret) {
-  const body = String(text4 ?? "");
-  const position = Math.max(0, Math.min(caret, body.length));
-  for (let index = position - 1; index >= 0; index -= 1) {
-    const character = body[index];
-    if (character === "@") {
-      if (index > 0 && !/\s/u.test(body[index - 1])) {
-        return null;
-      }
-      return { query: body.slice(index + 1, position).toLowerCase(), start: index };
-    }
-    if (/\s/u.test(character)) {
-      return null;
-    }
-  }
-  return null;
-}
-var mentionMatchScore = (author, needle) => {
-  if (needle.length === 0) {
-    return 1;
-  }
-  const name = author.name.toLowerCase();
-  if (name.startsWith(needle)) {
-    return 0;
-  }
-  if (name.includes(needle) || (author.initials || "").toLowerCase().startsWith(needle)) {
-    return 2;
-  }
-  return -1;
-};
-function matchCommentMentionAuthors(authors, query, limit = 6) {
-  const needle = String(query ?? "").trim().toLowerCase();
-  const scored = authors.filter((author) => author.id && author.name).map((author) => ({ author, score: mentionMatchScore(author, needle) })).filter((entry6) => entry6.score >= 0);
-  scored.sort((a, b) => a.score - b.score || a.author.name.localeCompare(b.author.name));
-  return scored.slice(0, limit).map((entry6) => entry6.author);
-}
-function defaultMentionId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return `{${crypto.randomUUID().toUpperCase()}}`;
-  }
-  const hex2 = (length) => Array.from(
-    { length },
-    () => Math.floor(Math.random() * 16).toString(16).toUpperCase()
-  ).join("");
-  return `{${hex2(8)}-${hex2(4)}-4${hex2(3)}-8${hex2(3)}-${hex2(12)}}`;
-}
-function insertCommentMention(text4, mentions, caret, author, generateId = defaultMentionId) {
-  const body = String(text4 ?? "");
-  const active2 = commentMentionQuery(body, caret);
-  const start = active2 ? active2.start : Math.max(0, Math.min(caret, body.length));
-  const end = active2 ? active2.start + 1 + active2.query.length : start;
-  const label3 = `@${author.name}`;
-  const nextText = `${body.slice(0, start)}${label3} ${body.slice(end)}`;
-  const delta = label3.length + 1 - (end - start);
-  const shifted = (mentions ?? []).map(
-    (mention) => mention.startIndex >= end ? { ...mention, startIndex: mention.startIndex + delta } : mention
-  );
-  shifted.push({
-    id: generateId(),
-    personId: author.id,
-    authorName: author.name,
-    startIndex: start,
-    length: label3.length
-  });
-  shifted.sort((a, b) => a.startIndex - b.startIndex);
-  return { text: nextText, mentions: shifted, caret: start + label3.length + 1 };
-}
-
 // src/pptx/render/comment-markers.ts
 var COMMENT_MARKER_SIZE = 20;
 var COMMENT_MARKER_COLOR = "rgba(255, 165, 0, 0.9)";
@@ -52026,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),
@@ -55933,23 +56370,23 @@ function getPasswordStrength(password) {
   if (!password) {
     return 0;
   }
-  let score = 0;
+  let score2 = 0;
   if (password.length >= 8) {
-    score += 1;
+    score2 += 1;
   }
   if (password.length >= 12) {
-    score += 1;
+    score2 += 1;
   }
   if (/[A-Z]/u.test(password) && /[a-z]/u.test(password)) {
-    score += 1;
+    score2 += 1;
   }
   if (/\d/u.test(password)) {
-    score += 1;
+    score2 += 1;
   }
   if (/[^A-Za-z0-9]/u.test(password)) {
-    score += 1;
+    score2 += 1;
   }
-  return Math.min(score, 4);
+  return Math.min(score2, 4);
 }
 function validatePasswordPair(password, confirmation) {
   if (!password) {
@@ -62831,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) {
@@ -68223,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)
@@ -77453,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;
   };
 }
 
@@ -79561,11 +79998,11 @@ function nextSelectActive(choices3, active2, step2) {
 }
 var SELECT_PAGE_SIZE = 8;
 function pageSelectActive(choices3, active2, direction) {
-  const usable = (index) => !choices3[index]?.disabled && !choices3[index]?.hidden;
+  const usable2 = (index) => !choices3[index]?.disabled && !choices3[index]?.hidden;
   const last = choices3.length - 1;
   const target = Math.max(0, Math.min(last, Math.max(active2, 0) + direction * SELECT_PAGE_SIZE));
   for (let index = target; index >= 0 && index <= last; index -= direction)
-    if (usable(index)) return index;
+    if (usable2(index)) return index;
   return active2;
 }
 
@@ -82554,7 +82991,7 @@ function definePptxInsertSmartArtDialog(registry2) {
       if (this.#live || this.#draw) {
         return;
       }
-      this.#live = import('./smartart-insert-preview-3BY6HNZL.cjs').then((module) => {
+      this.#live = import('./smartart-insert-preview-DHQ47GXP.cjs').then((module) => {
         if (this.#draw || !this.#picker) {
           return;
         }
@@ -88688,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;
   }
@@ -89223,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
@@ -89276,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
   });
@@ -89291,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
   });
@@ -91625,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;
@@ -92479,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;
@@ -92706,6 +93145,7 @@ exports.flattenOutline = flattenOutline;
 exports.flattenSlideElements = flattenSlideElements;
 exports.flattenTagCollections = flattenTagCollections;
 exports.flattenViewerOptions = flattenViewerOptions;
+exports.followCommentEdit = followCommentEdit;
 exports.followingText = followingText;
 exports.fontAlignmentVerticalAlign = fontAlignmentVerticalAlign;
 exports.fontFamilyItems = fontFamilyItems;
@@ -92726,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;
@@ -93355,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;
@@ -93956,6 +94398,7 @@ exports.transitionsLabel = transitionsLabel;
 exports.translateChartFormatText = translateChartFormatText2;
 exports.translateMotionPath = translateMotionPath;
 exports.travelledBox = travelledBox;
+exports.trimCommentMentions = trimCommentMentions;
 exports.trimmedMediaDurationMs = trimmedMediaDurationMs;
 exports.updateGlowPatch = updateGlowPatch;
 exports.updateGradientStopPatch = updateGradientStopPatch;