pptx-angular-viewer 1.14.1 → 1.16.0

package/fesm2022/pptx-angular-viewer.mjs

@@ -20766,6 +20766,51 @@ function defaultTextAdvancedState() {
         rtl: false,
     };
 }
+// ==========================================================================
+// Text wrap + autofit mode (standalone; not part of TextAdvancedState so
+// existing consumers of that interface are unaffected by this addition).
+// ==========================================================================
+/** Available text-wrap options (`a:bodyPr/@wrap`). */
+const TEXT_WRAP_OPTIONS = [
+    ['square', 'Wrap text in shape'],
+    ['none', "Don't wrap text"],
+];
+/**
+ * Available autofit-mode options. Per this codebase's {@link TextStyle.autoFitMode}
+ * mapping: `'shrink'` is `a:spAutoFit` (resize the shape to fit the text) and
+ * `'normal'` is `a:normAutofit` (shrink the text on overflow).
+ */
+const AUTOFIT_MODE_OPTIONS = [
+    ['none', 'Do not autofit'],
+    ['normal', 'Shrink text on overflow'],
+    ['shrink', 'Resize shape to fit text'],
+];
+/** Read the effective text-wrap mode, defaulting to `'square'` (wrap on). */
+function textWrapOf(el) {
+    if (!hasTextProperties(el)) {
+        return 'square';
+    }
+    return el.textStyle?.textWrap ?? 'square';
+}
+/** Read the effective autofit mode, defaulting to `'none'`. */
+function autoFitModeOf(el) {
+    if (!hasTextProperties(el)) {
+        return 'none';
+    }
+    return el.textStyle?.autoFitMode ?? 'none';
+}
+/** Patch to update the text-wrap mode, preserving the rest of `textStyle`. */
+function textWrapPatch(el, wrap) {
+    const base = hasTextProperties(el) ? (el.textStyle ?? {}) : {};
+    return { textStyle: { ...base, textWrap: wrap } };
+}
+/** Patch to update the autofit mode, preserving the rest of `textStyle`. */
+function autoFitModePatch(el, mode) {
+    const base = hasTextProperties(el) ? (el.textStyle ?? {}) : {};
+    return {
+        textStyle: { ...base, autoFitMode: mode, autoFit: mode !== 'none' },
+    };
+}
 
 /**
  * PPTX document-theme font + colour resolution helpers.
@@ -22822,7 +22867,7 @@ function assignUserColor(seed, palette = CURSOR_PALETTE) {
  * truncating, the result is exactly `maxChars` characters including a trailing
  * `...` ellipsis.
  */
-function formatCursorLabel$1(userName, maxChars = MAX_LABEL_CHARS) {
+function formatCursorLabel(userName, maxChars = MAX_LABEL_CHARS) {
     if (userName.length <= maxChars) {
         return userName;
     }
@@ -22953,6 +22998,175 @@ function asSelectionIds(value) {
     return value.filter((entry) => typeof entry === 'string');
 }
 
+/**
+ * Create a throttled presence publisher bound to an awareness instance. The
+ * initial presence is announced synchronously so peers learn of us at once.
+ */
+function createPresencePublisher(awareness, identity) {
+    const local = { activeSlideIndex: 0, cursorX: 0, cursorY: 0 };
+    // Starts at 0 so the first real update publishes immediately (the initial
+    // announce below does not consume the throttle budget).
+    let lastBroadcast = 0;
+    let pending = null;
+    function publish() {
+        awareness.setLocalStateField('presence', {
+            userName: identity.userName,
+            userColor: identity.userColor,
+            userAvatar: identity.userAvatar,
+            role: identity.role,
+            activeSlideIndex: local.activeSlideIndex,
+            cursorX: local.cursorX,
+            cursorY: local.cursorY,
+            selectedElementId: local.selectedElementId,
+            lastUpdated: new Date().toISOString(),
+        });
+    }
+    function update(patch) {
+        Object.assign(local, patch);
+        const elapsed = Date.now() - lastBroadcast;
+        if (elapsed >= BROADCAST_THROTTLE_MS) {
+            if (pending !== null) {
+                clearTimeout(pending);
+                pending = null;
+            }
+            lastBroadcast = Date.now();
+            publish();
+        }
+        else if (pending === null) {
+            pending = setTimeout(() => {
+                pending = null;
+                lastBroadcast = Date.now();
+                publish();
+            }, BROADCAST_THROTTLE_MS - elapsed);
+        }
+    }
+    function flush() {
+        if (pending !== null) {
+            clearTimeout(pending);
+            pending = null;
+        }
+        lastBroadcast = Date.now();
+        publish();
+    }
+    function dispose() {
+        if (pending !== null) {
+            clearTimeout(pending);
+            pending = null;
+        }
+    }
+    // Announce initial presence immediately (without consuming the throttle).
+    publish();
+    return { update, flush, dispose };
+}
+
+/**
+ * collaboration-assets.ts: binary payload sync for the pptx-viewer
+ * collaboration stack.
+ *
+ * Large binary element fields (media/OLE/3D-model payloads) are synced once
+ * via a separate `pptx:assets` Y.Map keyed by `${elementId}:${fieldName}`,
+ * instead of being re-embedded as base64 inside every element write. This
+ * avoids re-transmitting multi-MB payloads on every unrelated edit to the
+ * same element: `writeAssetFields` only touches the assets map when the
+ * stored payload actually differs from the incoming value.
+ *
+ * Known, accepted cost: asset entries are NOT garbage-collected when the
+ * element that referenced them is deleted outright (only an explicit
+ * field-clear removes its entry, via the `else` branch below). A long-lived
+ * room's `pptx:assets` map can only grow. No sweep is implemented in this
+ * pass; correct GC across concurrent/offline peers is a separate problem.
+ */
+const YDOC_ASSETS_KEY = 'pptx:assets';
+/**
+ * Element fields large/binary enough to route through the asset map instead
+ * of being embedded inline as a scalar or complex JSON-blob field.
+ */
+const ASSET_ELEMENT_FIELDS = new Set([
+    'mediaData',
+    'posterFrameData',
+    'oleEmbeddedData',
+    'previewImageData',
+    'modelData',
+]);
+const ASSET_REF_KEYS = {
+    mediaData: '_mdRef',
+    posterFrameData: '_pfdRef',
+    oleEmbeddedData: '_oedRef',
+    previewImageData: '_pidRef',
+    modelData: '_moRef',
+};
+const REV_ASSET_REF_KEYS = Object.fromEntries(Object.entries(ASSET_REF_KEYS).map(([field, ref]) => [ref, field]));
+function assetKey(elementId, fieldName) {
+    return `${elementId}:${fieldName}`;
+}
+function getAssetsMap(ydoc) {
+    return ydoc.getMap(YDOC_ASSETS_KEY);
+}
+/** True when `key` is one of the element-map ref-pointer keys this module owns. */
+function isAssetRefKey(key) {
+    return key in REV_ASSET_REF_KEYS;
+}
+/**
+ * Writes any present asset-routed fields from `rec` into `assets`, storing
+ * only a small ref pointer (not the payload) on the element's own `ymap`.
+ * Never reads from `ymap` itself, so it's safe to call on a brand-new,
+ * not-yet-integrated map (Yjs throws on reading an unintegrated type) - use
+ * this from a create/write path. `assets` is always a root-level (already
+ * integrated) map, so the identical-payload skip-write check is still safe.
+ */
+function writeAssetFields(elementId, rec, ymap, assets) {
+    for (const field of ASSET_ELEMENT_FIELDS) {
+        const value = rec[field];
+        if (typeof value === 'string' && value.length > 0) {
+            const key = assetKey(elementId, field);
+            if (assets.get(key) !== value) {
+                assets.set(key, value);
+            }
+            ymap.set(ASSET_REF_KEYS[field], key);
+        }
+    }
+}
+/**
+ * Reconcile variant of {@link writeAssetFields} for an `ymap` that is
+ * already integrated (an existing live element being updated in place):
+ * additionally reads the current ref to skip a redundant set, and clears
+ * the ref + its `assets` entry when the field was cleared.
+ */
+function reconcileAssetFields(elementId, rec, ymap, assets) {
+    for (const field of ASSET_ELEMENT_FIELDS) {
+        const refKey = ASSET_REF_KEYS[field];
+        const value = rec[field];
+        if (typeof value === 'string' && value.length > 0) {
+            const key = assetKey(elementId, field);
+            if (assets.get(key) !== value) {
+                assets.set(key, value);
+            }
+            if (ymap.get(refKey) !== key) {
+                ymap.set(refKey, key);
+            }
+        }
+        else {
+            const existingRef = ymap.get(refKey);
+            if (typeof existingRef === 'string') {
+                ymap.delete(refKey);
+                assets.delete(existingRef);
+            }
+        }
+    }
+}
+/** Rehydrates any asset-routed fields referenced by `ymap` onto `element`. */
+function readAssetFields(ymap, assets, element) {
+    for (const [refKey, field] of Object.entries(REV_ASSET_REF_KEYS)) {
+        const ref = ymap.get(refKey);
+        if (typeof ref === 'string') {
+            const value = assets.get(ref);
+            if (typeof value === 'string') {
+                element[field] = value;
+            }
+        }
+    }
+}
+
 /**
  * collaboration-text-codec.ts: TextSegment[] <-> Y.Text delta codec used by the
  * collaboration sync layer. Split out of collaboration-sync.ts to keep both
@@ -23221,6 +23435,9 @@ const SCALAR_ELEMENT_KEYS = new Set([
     'width',
     'height',
     'rotation',
+    'shapeId',
+    'skewX',
+    'skewY',
     'flipHorizontal',
     'flipVertical',
     'hidden',
@@ -23229,14 +23446,66 @@ const SCALAR_ELEMENT_KEYS = new Set([
     'name',
     'altText',
     'shapeType',
-    'placeholder',
     'imagePath',
     'imageData',
-    'svgContent',
-    'inkSvg',
-    'sourceSlideId',
+    'svgData',
+    'svgPath',
+    'cropLeft',
+    'cropTop',
+    'cropRight',
+    'cropBottom',
+    'tileOffsetX',
+    'tileOffsetY',
+    'tileScaleX',
+    'tileScaleY',
+    'tileFlip',
+    'tileAlignment',
+    'pathData',
+    'pathWidth',
+    'pathHeight',
     'mediaType',
     'mediaPath',
+    'mediaMimeType',
+    'trimStartMs',
+    'trimEndMs',
+    'posterFramePath',
+    'fullScreen',
+    'loop',
+    'fadeInDuration',
+    'fadeOutDuration',
+    'volume',
+    'autoPlay',
+    'playAcrossSlides',
+    'hideWhenNotPlaying',
+    'playbackSpeed',
+    'mediaMissing',
+    'isLinked',
+    'oleTarget',
+    'oleProgId',
+    'oleName',
+    'oleClsId',
+    'oleObjectType',
+    'oleFileExtension',
+    'fileName',
+    'externalPath',
+    'previewImage',
+    'oleShowAsIcon',
+    'oleImgW',
+    'oleImgH',
+    'oleEmbeddedFileName',
+    'oleEmbeddedMimeType',
+    'oleEmbeddedByteSize',
+    'inkPaths',
+    'inkColors',
+    'inkWidths',
+    'inkOpacities',
+    'inkTool',
+    'zoomType',
+    'targetSlideIndex',
+    'targetSectionId',
+    'modelPath',
+    'modelMimeType',
+    'posterImage',
     'linkedTxbxId',
     'linkedTxbxSeq',
     'promptText',
@@ -23249,26 +23518,35 @@ const COMPLEX_ELEMENT_FIELDS = {
     tableData: '_td',
     chartData: '_cd',
     smartArtData: '_smad',
-    connectionStart: '_cs',
-    connectionEnd: '_ce',
-    animations: '_an',
-    nativeAnimations: '_na',
     children: '_ch',
     paragraphIndents: '_pi',
     rawXml: '_rx',
+    extLstXml: '_elx',
     actionClick: '_ac',
     actionHover: '_av',
     locks: '_lk',
     imageEffects: '_ie',
     cropShape: '_cr',
-    mediaBookmarks: '_mb',
+    bookmarks: '_mb',
     captionTracks: '_ct',
+    metadata: '_md',
+    groupFill: '_gf',
+    inkPointPressures: '_ipp',
+    inkStrokes: '_cis',
+    extensionXml: '_ext',
+    customGeometryPaths: '_cgp',
+    customGeometryRawData: '_cgr',
+    customGeometryAdjustHandlesXY: '_cgx',
+    customGeometryAdjustHandlesPolar: '_cgo',
+    customGeometryConnectionSites: '_cgc',
+    customGeometryTextRect: '_cgt',
 };
 const REV_COMPLEX_ELEMENT = Object.fromEntries(Object.entries(COMPLEX_ELEMENT_FIELDS).map(([k, v]) => [v, k]));
 const SCALAR_SLIDE_KEYS = new Set([
     'id',
     'rId',
     'sourceSlideId',
+    'name',
     'layoutPath',
     'layoutName',
     'slideNumber',
@@ -23278,7 +23556,9 @@ const SCALAR_SLIDE_KEYS = new Set([
     'backgroundColor',
     'backgroundImage',
     'backgroundGradient',
+    'backgroundShadeToTitle',
     'notes',
+    'notesCSldName',
     'backgroundShowAnimation',
     'showMasterShapes',
     'isDirty',
@@ -23289,6 +23569,8 @@ const COMPLEX_SLIDE_FIELDS = {
     nativeAnimations: '_na',
     rawTiming: '_rt',
     notesSegments: '_ns',
+    notesShapes: '_nsh',
+    notesClrMapOverride: '_ncm',
     comments: '_cm',
     warnings: '_wa',
     rawXml: '_rx',
@@ -23296,15 +23578,17 @@ const COMPLEX_SLIDE_FIELDS = {
     guides: '_gu',
     customerData: '_cu',
     activeXControls: '_ax',
+    backgroundPattern: '_bp',
+    headerFooterFlags: '_hff',
 };
 const REV_COMPLEX_SLIDE = Object.fromEntries(Object.entries(COMPLEX_SLIDE_FIELDS).map(([k, v]) => [v, k]));
 // ---------------------------------------------------------------------------
 // Element serialization
 // ---------------------------------------------------------------------------
-function writeElementToYMap(element, ymap, factories) {
+function writeElementToYMap(element, ymap, factories, assets) {
     const rec = element;
     for (const [key, value] of Object.entries(rec)) {
-        if (value === undefined) {
+        if (value === undefined || ASSET_ELEMENT_FIELDS.has(key)) {
             continue;
         }
         if (SCALAR_ELEMENT_KEYS.has(key)) {
@@ -23321,8 +23605,9 @@ function writeElementToYMap(element, ymap, factories) {
             ymap.set(COMPLEX_ELEMENT_FIELDS[key], JSON.stringify(value));
         }
     }
+    writeAssetFields(rec.id, rec, ymap, assets);
 }
-function readElementFromYMap(ymap) {
+function readElementFromYMap(ymap, assets) {
     const element = {};
     ymap.forEach((value, key) => {
         if (key === 'textBody') {
@@ -23330,6 +23615,9 @@ function readElementFromYMap(ymap) {
                 element.textSegments = decodeTextBody(value);
             }
         }
+        else if (isAssetRefKey(key)) {
+            // handled by readAssetFields below; not a literal PptxElement field
+        }
         else if (REV_COMPLEX_ELEMENT[key]) {
             try {
                 element[REV_COMPLEX_ELEMENT[key]] = JSON.parse(value);
@@ -23342,12 +23630,13 @@ function readElementFromYMap(ymap) {
             element[key] = value;
         }
     });
+    readAssetFields(ymap, assets, element);
     return element;
 }
 // ---------------------------------------------------------------------------
 // Slide serialization
 // ---------------------------------------------------------------------------
-function writeSlideToYMap(slide, ymap, factories) {
+function writeSlideToYMap(slide, ymap, factories, assets) {
     const rec = slide;
     for (const key of SCALAR_SLIDE_KEYS) {
         if (rec[key] !== undefined) {
@@ -23362,12 +23651,12 @@ function writeSlideToYMap(slide, ymap, factories) {
     const elemArr = factories.createArray();
     for (const el of slide.elements) {
         const elemMap = factories.createMap();
-        writeElementToYMap(el, elemMap, factories);
+        writeElementToYMap(el, elemMap, factories, assets);
         elemArr.push([elemMap]);
     }
     ymap.set('elements', elemArr);
 }
-function readSlideFromYMap(ymap) {
+function readSlideFromYMap(ymap, assets) {
     const slide = {};
     for (const key of SCALAR_SLIDE_KEYS) {
         const v = ymap.get(key);
@@ -23390,7 +23679,7 @@ function readSlideFromYMap(ymap) {
     const elements = [];
     if (elemArr) {
         for (let i = 0; i < elemArr.length; i++) {
-            elements.push(readElementFromYMap(elemArr.get(i)));
+            elements.push(readElementFromYMap(elemArr.get(i), assets));
         }
     }
     slide.elements = elements;
@@ -23405,6 +23694,7 @@ function readSlideFromYMap(ymap) {
  * one-shot seeding of an empty document.
  */
 function writeSlidesToYDoc(slides, ydoc, factories, origin) {
+    const assets = getAssetsMap(ydoc);
     ydoc.transact(() => {
         const arr = ydoc.getArray(YDOC_SLIDES_KEY);
         if (arr.length > 0) {
@@ -23412,16 +23702,17 @@ function writeSlidesToYDoc(slides, ydoc, factories, origin) {
         }
         for (const slide of slides) {
             const ymap = factories.createMap();
-            writeSlideToYMap(slide, ymap, factories);
+            writeSlideToYMap(slide, ymap, factories, assets);
             arr.push([ymap]);
         }
     }, origin);
 }
 function readSlidesFromYDoc(ydoc) {
+    const assets = getAssetsMap(ydoc);
     const arr = ydoc.getArray(YDOC_SLIDES_KEY);
     const slides = [];
     for (let i = 0; i < arr.length; i++) {
-        slides.push(readSlideFromYMap(arr.get(i)));
+        slides.push(readSlideFromYMap(arr.get(i), assets));
     }
     return slides;
 }
@@ -23673,11 +23964,12 @@ function reconcileTextBody(ymap, rec, factories) {
     encodeTextBody(segments, ytext);
     ymap.set('textBody', ytext);
 }
-function reconcileElementYMap(ymap, element, factories) {
+function reconcileElementYMap(ymap, element, factories, assets) {
     const rec = element;
     reconcileScalars(ymap, rec, SCALAR_ELEMENT_KEYS);
     reconcileComplexFields(ymap, rec, COMPLEX_ELEMENT_FIELDS);
     reconcileTextBody(ymap, rec, factories);
+    reconcileAssetFields(rec.id, rec, ymap, assets);
 }
 function mapIdAt(arr, index) {
     const entry = arr.get(index);
@@ -23754,7 +24046,7 @@ const isYArrayLike = (value) => typeof value === 'object' &&
     value !== null &&
     typeof value.insert === 'function' &&
     typeof value.toArray === 'function';
-function reconcileSlideYMap(ymap, slide, factories) {
+function reconcileSlideYMap(ymap, slide, factories, assets) {
     const rec = slide;
     reconcileScalars(ymap, rec, SCALAR_SLIDE_KEYS);
     reconcileComplexFields(ymap, rec, COMPLEX_SLIDE_FIELDS);
@@ -23767,10 +24059,10 @@ function reconcileSlideYMap(ymap, slide, factories) {
         idOf: (el) => (typeof el.id === 'string' ? el.id : undefined),
         create: (el) => {
             const map = factories.createMap();
-            writeElementToYMap(el, map, factories);
+            writeElementToYMap(el, map, factories, assets);
             return map;
         },
-        update: (map, el) => reconcileElementYMap(map, el, factories),
+        update: (map, el) => reconcileElementYMap(map, el, factories, assets),
     });
 }
 /**
@@ -23779,16 +24071,17 @@ function reconcileSlideYMap(ymap, slide, factories) {
  * caller's own observer can skip the resulting events.
  */
 function reconcileSlidesInYDoc(slides, ydoc, factories, origin = LOCAL_SYNC_ORIGIN) {
+    const assets = getAssetsMap(ydoc);
     ydoc.transact(() => {
         const arr = ydoc.getArray(YDOC_SLIDES_KEY);
         reconcileYArrayById(arr, slides, {
             idOf: (slide) => (typeof slide.id === 'string' ? slide.id : undefined),
             create: (slide) => {
                 const map = factories.createMap();
-                writeSlideToYMap(slide, map, factories);
+                writeSlideToYMap(slide, map, factories, assets);
                 return map;
             },
-            update: (map, slide) => reconcileSlideYMap(map, slide, factories),
+            update: (map, slide) => reconcileSlideYMap(map, slide, factories, assets),
         });
     }, origin);
 }
@@ -23845,6 +24138,50 @@ function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
     };
 }
 
+const DEFAULT_DEBOUNCE_MS = 5_000;
+function createWriteBackScheduler(deps) {
+    let timer = null;
+    function cancel() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    function schedule(config) {
+        if (!config.onWriteBack || config.role !== 'owner' || !deps.getYDoc()) {
+            return;
+        }
+        cancel();
+        const debounceMs = config.writeBackDebounceMs ?? DEFAULT_DEBOUNCE_MS;
+        timer = setTimeout(async () => {
+            timer = null;
+            const ydoc = deps.getYDoc();
+            if (!ydoc || !config.onWriteBack) {
+                return;
+            }
+            const sourceBytes = deps.getSourceBytes?.();
+            if (!sourceBytes) {
+                return;
+            }
+            try {
+                const { PptxHandler } = await import('pptx-viewer-core');
+                const handler = new PptxHandler();
+                await handler.load(sourceBytes.buffer);
+                const slides = readSlidesFromYDoc(ydoc);
+                const merged = deps.mergeTemplateElements
+                    ? deps.mergeTemplateElements(slides, deps.getTemplateElements?.() ?? {})
+                    : slides;
+                const bytes = await handler.save(merged);
+                config.onWriteBack(bytes);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }, debounceMs);
+    }
+    return { schedule, cancel };
+}
+
 // ---------------------------------------------------------------------------
 // Tuning constants (px tolerances for position / size changes)
 // ---------------------------------------------------------------------------
@@ -31881,6 +32218,155 @@ function sanitizeStops(raw) {
     return sortStops(mapped);
 }
 
+/**
+ * Pure (framework-agnostic) helpers for the image adjustments + crop inspector
+ * panel. Readers extract current values from a PptxElement (falling back to
+ * sensible defaults); patch-builders produce shallow-merge-ready
+ * `Partial<PptxElement>` objects safe to pass to each binding's element-update
+ * action. Mirrors the pattern used by `gradient-picker.ts` / `text-advanced.ts`.
+ *
+ * Scope: brightness/contrast/saturation (`PptxImageEffects`) and the four crop
+ * insets (`PptxImageProperties.cropLeft/Top/Right/Bottom`). Other image effects
+ * (duotone, artistic filters, alpha primitives) are out of scope for the
+ * inspector's "highest-traffic" surface; see `image-effects.ts` for the full
+ * read-side effect model.
+ */
+/** Read the current brightness/contrast/saturation off an element (0 when unset). */
+function imageAdjustmentsStateOf(el) {
+    const fx = isImageLikeElement(el) ? el.imageEffects : undefined;
+    return {
+        brightness: fx?.brightness ?? 0,
+        contrast: fx?.contrast ?? 0,
+        saturation: fx?.saturation ?? 0,
+    };
+}
+/**
+ * Build a Partial<PptxElement> that merges the given adjustment changes into
+ * the element's existing `imageEffects` without dropping other effect fields.
+ * No-op (returns `{}`) for non-image elements.
+ */
+function imageAdjustmentsPatch(el, changes) {
+    if (!isImageLikeElement(el)) {
+        return {};
+    }
+    return {
+        imageEffects: {
+            ...el.imageEffects,
+            ...changes,
+        },
+    };
+}
+/** Read the current crop insets off an element (0 on every edge when unset). */
+function imageCropStateOf(el) {
+    if (!isImageLikeElement(el)) {
+        return { cropLeft: 0, cropTop: 0, cropRight: 0, cropBottom: 0 };
+    }
+    return {
+        cropLeft: el.cropLeft ?? 0,
+        cropTop: el.cropTop ?? 0,
+        cropRight: el.cropRight ?? 0,
+        cropBottom: el.cropBottom ?? 0,
+    };
+}
+/** Clamp a crop fraction to the sane `[0, 0.9]` range (never crop past 90% of an edge). */
+function clampCropFraction(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(0.9, Math.max(0, value));
+}
+/**
+ * Build a Partial<PptxElement> that merges the given crop-inset changes onto
+ * the element. No-op (returns `{}`) for non-image elements.
+ */
+function imageCropPatch(el, changes) {
+    if (!isImageLikeElement(el)) {
+        return {};
+    }
+    const patch = {};
+    for (const [key, value] of Object.entries(changes)) {
+        if (value !== undefined) {
+            patch[key] = clampCropFraction(value);
+        }
+    }
+    return patch;
+}
+
+/**
+ * Pure (framework-agnostic) helpers for the table-level inspector panel
+ * (header row / banded rows toggles + a uniform default cell padding). Mirrors
+ * the reader + patch-builder pattern used by `gradient-picker.ts` /
+ * `text-advanced.ts` / `image-adjustments.ts`.
+ *
+ * Scope note: this binding has no per-cell selection model, so cell-level
+ * formatting (background/border for one specific cell) is out of scope here;
+ * `applyUniformCellPaddingPatch` instead writes the same margin onto every
+ * cell uniformly, which is the closest table-level equivalent.
+ */
+/** Read table-level flags off a table element (all false/0 for non-table elements). */
+function tableInspectorStateOf(el) {
+    if (el.type !== 'table' || !el.tableData) {
+        return { firstRowHeader: false, bandedRows: false, bandedColumns: false, cellPadding: 0 };
+    }
+    const data = el.tableData;
+    return {
+        firstRowHeader: data.firstRowHeader ?? false,
+        bandedRows: data.bandedRows ?? false,
+        bandedColumns: data.bandedColumns ?? false,
+        cellPadding: firstCellPadding(data),
+    };
+}
+function firstCellPadding(data) {
+    const firstCell = data.rows[0]?.cells[0];
+    return firstCell?.style?.marginLeft ?? 0;
+}
+/**
+ * Build a Partial<PptxElement> that merges the given flag changes into the
+ * element's existing `tableData`. No-op (returns `{}`) for non-table elements
+ * or a table with no parsed data.
+ */
+function tableInspectorPatch(el, changes) {
+    if (el.type !== 'table' || !el.tableData) {
+        return {};
+    }
+    return {
+        tableData: {
+            ...el.tableData,
+            ...changes,
+        },
+    };
+}
+/**
+ * Build a Partial<PptxElement> that sets the same left/right/top/bottom margin
+ * (in px) on every cell of every row, so the table gets uniform default
+ * padding. No-op (returns `{}`) for non-table elements or a table with no rows.
+ */
+function applyUniformCellPaddingPatch(el, padding) {
+    if (el.type !== 'table' || !el.tableData) {
+        return {};
+    }
+    const clamped = Math.max(0, Math.round(padding));
+    const rows = el.tableData.rows.map((row) => ({
+        ...row,
+        cells: row.cells.map((cell) => ({
+            ...cell,
+            style: {
+                ...cell.style,
+                marginLeft: clamped,
+                marginRight: clamped,
+                marginTop: clamped,
+                marginBottom: clamped,
+            },
+        })),
+    }));
+    return {
+        tableData: {
+            ...el.tableData,
+            rows,
+        },
+    };
+}
+
 /**
  * Pure, framework-agnostic comment-array transforms, shared by every binding.
  *
@@ -33088,6 +33574,51 @@ const CHANGE_CASE_OPTIONS$1 = [
     { value: 'toggle', i18nKey: 'pptx.text.changeCaseToggle' },
 ];
 
+/**
+ * color-swatches.ts: the canonical "Office Standard Colors" swatch catalogue
+ * shared by every binding's colour pickers (font colour, highlight colour,
+ * and any future fill/line colour picker that wants the same 10-swatch grid).
+ *
+ * Mirrors the "Standard Colors" row PowerPoint itself ships. Before this
+ * module existed, the VanillaJS (`swatch-picker.ts`) and Svelte
+ * (`SwatchColorPicker.svelte`) bindings each independently hardcoded an
+ * identical 10-colour list; this module is the single source of truth going
+ * forward so no binding drifts from the others.
+ *
+ * There is no shared-i18n dictionary key for individual colour names yet
+ * (only the `pptx.ribbon.customColour` "Custom colour..." row label exists),
+ * so {@link OfficeColorSwatch.label} is a plain English fallback rather than
+ * an `i18nKey`, matching the optional-label convention used elsewhere in this
+ * module family (e.g. `LineSpacingOption` in `text-format-presets.ts`).
+ *
+ * @module render/color-swatches
+ */
+/**
+ * The canonical 10-swatch "Office Standard Colors" catalogue, in PowerPoint's
+ * on-screen order. Consumed by the font-colour and highlight-colour pickers
+ * (and any other picker that wants the same standard set) across every
+ * binding.
+ */
+const OFFICE_COLOR_SWATCHES = [
+    { hex: '#000000', label: 'Black' },
+    { hex: '#ffffff', label: 'White' },
+    { hex: '#ff0000', label: 'Red' },
+    { hex: '#00aa00', label: 'Green' },
+    { hex: '#0000ff', label: 'Blue' },
+    { hex: '#ff8800', label: 'Orange' },
+    { hex: '#8800cc', label: 'Purple' },
+    { hex: '#00cccc', label: 'Cyan' },
+    { hex: '#ff69b4', label: 'Pink' },
+    { hex: '#808080', label: 'Gray' },
+];
+/**
+ * The same catalogue flattened to bare `#rrggbb` hex strings, in the same
+ * order as {@link OFFICE_COLOR_SWATCHES}. A drop-in replacement for the
+ * `readonly string[]` swatch lists the vanilla and Svelte bindings each
+ * hardcoded locally before this module existed.
+ */
+const OFFICE_COLOR_SWATCH_HEXES = OFFICE_COLOR_SWATCHES.map((swatch) => swatch.hex);
+
 /**
  * PowerPoint-style title bar: shared pure logic + Tailwind class tokens.
  *
@@ -37508,25 +38039,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
  * surface so `collaboration.service.ts`, `collaboration-cursors.component.ts`,
  * the viewer barrel, and the colocated tests are unchanged.
  *
- * Two pieces stay Angular-local because they diverge from the shared copy:
- *  - `RemotePresence` is the Angular name for shared's `SanitizedPresence`
- *    (re-aliased here).
- *  - `formatCursorLabel` keeps the historical single-character ellipsis (`…`)
- *    truncation, which differs from shared's three-dot (`...`) variant that the
- *    React binding expects. Kept local so the rendered label and the colocated
- *    test are unchanged.
- *
- * `mapAwarenessCursors` (the foundational bare-`{ cursor, user }` mapping) now
- * lives in shared and is re-exported here so existing Angular imports are
- * unchanged.
- */
-/**
- * Clamp/format a cursor label so long names don't overflow the chip. Uses a
- * single-character ellipsis (`…`); the total length is exactly `maxChars`.
+ * `RemotePresence` is the Angular name for shared's `SanitizedPresence`
+ * (re-aliased here). `formatCursorLabel` and `mapAwarenessCursors` are now
+ * re-exported as-is from shared: Angular's `formatCursorLabel` used to keep
+ * its own single-character ellipsis (`…`) truncation that differed from
+ * shared's three-dot (`...`) variant, so two peers viewing the same presence
+ * record saw differently-truncated names depending on which binding hosted
+ * the session - a real cross-binding consistency bug, not a style choice.
  */
-function formatCursorLabel(userName, maxChars = MAX_LABEL_CHARS) {
-    return userName.length > maxChars ? `${userName.slice(0, maxChars - 1)}…` : userName;
-}
 
 /**
  * collaboration-cursors.component.ts: Angular port of the Vue
@@ -37668,8 +38188,6 @@ class LocalPresencePublisher {
     setCursor(x, y, activeSlideIndex = this.activeSlide) {
         this.cursor = { x, y };
         this.activeSlide = activeSlideIndex;
-        // A bare `cursor` field mirrors the flat awareness shape some peers read.
-        this.awareness.setLocalStateField('cursor', { x, y });
         this.publish();
     }
     setSelection(selectedElementId, activeSlideIndex = this.activeSlide) {
@@ -37689,14 +38207,14 @@ class LocalPresencePublisher {
  *
  * Isolates the dynamic `yjs` / `y-websocket` / `y-webrtc` imports and provider
  * construction so the service focuses on lifecycle + reactive state. The Yjs
- * packages are dynamically imported so they are fully tree-shaken when
- * collaboration is unused; each specifier is read from a variable so bundlers
- * do not eagerly follow it (mirrors the historical `/* @vite-ignore *\/`
- * pattern).
+ * packages are dynamically imported (plain string-literal specifiers, matching
+ * React/Vue) so they are fully tree-shaken when collaboration is unused, while
+ * still resolving correctly under a consuming app's Vite dev server: an
+ * `@vite-ignore`d or variable specifier skips Vite's dev-time bare-specifier
+ * rewrite, which then fails to resolve natively in the browser.
  */
 async function createDoc() {
-    const yModule = 'yjs';
-    const Y = (await import(/* @vite-ignore */ yModule));
+    const Y = (await import('yjs'));
     const doc = new Y.Doc();
     const factories = {
         createMap: () => new Y.Map(),
@@ -37707,10 +38225,9 @@ async function createDoc() {
 }
 /** Create a y-websocket transport bundle for `config`. */
 async function createWebsocketBundle(config) {
-    const wsSpecifier = 'y-websocket';
     const [{ doc, factories }, yws] = await Promise.all([
         createDoc(),
-        import(/* @vite-ignore */ wsSpecifier),
+        import('y-websocket'),
     ]);
     const provider = new yws.WebsocketProvider(config.serverUrl, config.roomId, doc, config.authToken ? { params: { token: config.authToken } } : undefined);
     return { doc, provider, awareness: provider.awareness, factories };
@@ -37722,10 +38239,9 @@ async function createWebsocketBundle(config) {
  * `authToken` is passed as the room `password`.
  */
 async function createWebrtcBundle(config) {
-    const rtcSpecifier = 'y-webrtc';
     const [{ doc, factories }, yrtc] = await Promise.all([
         createDoc(),
-        import(/* @vite-ignore */ rtcSpecifier),
+        import('y-webrtc'),
     ]);
     const provider = new yrtc.WebrtcProvider(config.roomId, doc, {
         signaling: config.signaling?.length ? config.signaling : undefined,
@@ -37950,9 +38466,14 @@ class CollaborationService {
             this.status.set('error');
             return;
         }
+        // Falls back from a blank serverUrl the same way Vue's session layer
+        // already does, so a bare CollaborationConfig behaves identically
+        // regardless of which binding's session layer receives it directly (not
+        // just via the Share/Broadcast dialogs, which already pre-resolve it).
+        const transport = config.transport ?? resolveTransportForServerUrl(config.serverUrl);
         // Fail fast on mixed content (websocket only): an https page cannot open a
         // ws:// socket, so surface the error rather than hanging until the timeout.
-        if (config.transport !== 'webrtc' && isMixedContentBlocked(config.serverUrl)) {
+        if (transport !== 'webrtc' && isMixedContentBlocked(config.serverUrl)) {
             this.status.set('error');
             return;
         }
@@ -37965,7 +38486,7 @@ class CollaborationService {
         this.activeRole.set(config.role);
         this.status.set('connecting');
         try {
-            const bundle = config.transport === 'webrtc'
+            const bundle = transport === 'webrtc'
                 ? await createWebrtcBundle(config)
                 : await createWebsocketBundle(config);
             this.ydoc = bundle.doc;
@@ -37982,7 +38503,7 @@ class CollaborationService {
             this.localPresence.publish();
             this.awareness.on('change', this.refreshPresence);
             this.awareness.on('update', this.refreshPresence);
-            this.wireStatus(config);
+            this.wireStatus(transport);
             this.syncGate.reset();
             this.wireSynced();
             this.unobserveSlides = observeYDocSlides(this.ydoc, (_events, transaction) => this.onRemoteChange(transaction));
@@ -38001,18 +38522,23 @@ class CollaborationService {
         }
     }
     /** Wire the provider status events + (websocket-only) connection timeout. */
-    wireStatus(config) {
+    wireStatus(transport) {
         const provider = this.provider;
         if (!provider) {
             return;
         }
-        if (config.transport === 'webrtc') {
+        if (transport === 'webrtc') {
             // P2P: no server round-trip to wait on. Treat "created" as connected,
             // and reflect explicit disconnect events.
             this.status.set('connected');
             provider.on('status', (payload) => {
                 if (payload.connected === false && this.active()) {
                     this.status.set('disconnected');
+                    // Re-arm on (re)connect: without this, a peer that drops and
+                    // rejoins keeps the gate permanently open from the first
+                    // connection and can clobber the room with a stale local doc.
+                    this.syncGate.reset();
+                    this.syncGate.arm();
                 }
                 else if (payload.connected === true) {
                     this.status.set('connected');
@@ -38027,6 +38553,8 @@ class CollaborationService {
             }
             else if (payload.status === 'disconnected' && this.active()) {
                 this.status.set('disconnected');
+                this.syncGate.reset();
+                this.syncGate.arm();
             }
         });
         if (provider.wsconnected) {
@@ -40044,6 +40572,7 @@ const translationsEn = {
     'pptx.table.bandRowCycle': 'Row band size',
     'pptx.table.cell': 'Cell R{{row}} C{{col}}',
     'pptx.table.cellBorders': 'Cell borders',
+    'pptx.table.cellPadding': 'Cell padding',
     'pptx.table.color': 'Text',
     'pptx.table.columnWidths': 'Column widths',
     'pptx.table.even': 'Even',
@@ -40585,6 +41114,9 @@ const translationsEn = {
     'pptx.ribbon.strokeWidth': 'Stroke width',
     'pptx.ribbon.browseThemes': 'Browse Themes',
     'pptx.ribbon.browseThemesTitle': 'Browse and apply built-in themes',
+    'pptx.ribbon.theme.default': 'Default',
+    'pptx.ribbon.theme.light': 'Light (Vermilion)',
+    'pptx.ribbon.theme.dark': 'Dark (Vermilion)',
     'pptx.ribbon.editTheme': 'Edit Theme',
     'pptx.ribbon.editThemeTitle': 'Edit theme - theme editor not yet ported',
     'pptx.ribbon.slideSize': 'Slide Size',
@@ -41337,6 +41869,10 @@ const translationsEn = {
     'pptx.text.characterSpacingTight': 'Tight',
     'pptx.text.characterSpacingVeryLoose': 'Very Loose',
     'pptx.text.characterSpacingVeryTight': 'Very Tight',
+    'pptx.textAdvanced.autoFit': 'AutoFit',
+    'pptx.textAdvanced.autoFitNone': 'Do not autofit',
+    'pptx.textAdvanced.autoFitResize': 'Resize shape to fit text',
+    'pptx.textAdvanced.autoFitShrink': 'Shrink text on overflow',
     'pptx.textAdvanced.autoPlaceholder': 'auto',
     'pptx.textAdvanced.indent': 'Indent',
     'pptx.textAdvanced.indentMargin': 'Indent & Margin',
@@ -41350,6 +41886,7 @@ const translationsEn = {
     'pptx.textAdvanced.spaceBefore': 'Space Before',
     'pptx.textAdvanced.spacing': 'Spacing',
     'pptx.textAdvanced.vAlign': 'V-Align',
+    'pptx.textAdvanced.wrapText': 'Wrap text in shape',
     'pptx.textFormatting.bulleted': 'Bulleted',
     'pptx.textFormatting.numbered': 'Numbered',
     'pptx.textFormatting.paragraphAfter': 'Paragraph After',