ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/media-playback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-playback.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-playback.ts"],"names":[],"mappings":"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"}

package/dist/pptx/render/media-trim-fade-scheduler.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Trim-end stop and fade in/out playback scheduling for a live media element
+ * (G20). Split out of `media-playback.ts` (already at the file-size cap) to
+ * keep both files under it.
+ *
+ * WHY this exists: `startMediaAutoplay` seeks to `trimStartMs` and calls
+ * `.play()` once, but stopping at a trim END and ramping volume in/out around
+ * the trim boundaries takes an ongoing scheduler (a `play` listener, a couple
+ * of timers, and an animation-frame volume ramp) - logic that used to live
+ * ONLY in React's `media-controller.tsx`, so trimmed/faded clips played past
+ * their trim end, unfaded, in the other four bindings.
+ *
+ * `source.trimEndMs` mirrors `p14:trim/@end`'s own on-the-wire unit: the
+ * distance, in milliseconds, from the END of the clip, NOT an absolute stop
+ * time (COM-verified; see `PptxHandlerRuntimeMediaParsingUtils.ts`'s
+ * `MediaExtensionData` doc). Converting it to an absolute stop needs the
+ * clip's real duration, which is only known once the browser has decoded
+ * metadata, so that conversion happens here, at schedule time, via a
+ * `loadedmetadata` listener when `el.duration` is not yet available.
+ */
+export interface MediaTrimFadeSource {
+    /** `p14:trim/@st`: absolute milliseconds from the clip's start. */
+    trimStartMs?: number;
+    /** `p14:trim/@end`: distance, in milliseconds, from the clip's END. */
+    trimEndMs?: number;
+    /** `p14:fade/@in`, in seconds. */
+    fadeInDuration?: number;
+    /** `p14:fade/@out`, in seconds. */
+    fadeOutDuration?: number;
+    /** The DOM-facing target volume (post `mediaPlaybackAttributes` clamp). */
+    volume?: number;
+}
+/**
+ * Attach trim-end stop and fade in/out scheduling to a media element for as
+ * long as it keeps playing. Re-arms on every `play` (a manual replay, a loop,
+ * or `startMediaAutoplay`'s own `.play()` call all fire it), and applies the
+ * trim-start seek + fade-in immediately when playback (re)starts.
+ *
+ * Returns a cleanup function that cancels any pending timer/animation frame
+ * and removes the listeners; call it on unmount or before rescheduling with
+ * new settings.
+ */
+export declare function scheduleMediaTrimAndFade(el: HTMLMediaElement, source: MediaTrimFadeSource): () => void;
+//# sourceMappingURL=media-trim-fade-scheduler.d.ts.map

package/dist/pptx/render/media-trim-fade-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-trim-fade-scheduler.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-trim-fade-scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,mBAAmB;IACnC,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mCAAmC;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACvC,EAAE,EAAE,gBAAgB,EACpB,MAAM,EAAE,mBAAmB,GACzB,MAAM,IAAI,CAyIZ"}

package/dist/pptx/render/media-trim-range.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Trim-range validation and labelling for the media inspector, shared by every
+ * binding's trim editor.
+ *
+ * `trimEndMs` is `p14:trim/@end`'s on-the-wire unit: the distance in
+ * milliseconds from the END of the clip (COM-verified, see
+ * `media-trim-timeline.ts`), not an absolute stop time. The inspector shows the
+ * user an absolute "End (mm:ss)" position, so this module owns both directions
+ * of that conversion in ms; `media-trim-timeline.ts` has the seconds variants
+ * the scrubber geometry uses.
+ *
+ * @module media-trim-range
+ */
+/** Why a trim range is rejected; bindings map these onto their i18n keys. */
+export type MediaTrimRangeError = 'negative' | 'startAfterEnd' | 'beyondDuration';
+/**
+ * Absolute trim-end position in ms for a distance-from-tail `trimEndMs`.
+ * `0` (or an unset/negative value) means "play to the end". When the clip
+ * duration is unknown (`durationMs <= 0`) the raw value is returned unchanged
+ * because there is nothing to measure the tail from.
+ */
+export declare function mediaTrimEndAbsoluteMs(durationMs: number, trimEndMs: number): number;
+/**
+ * Inverse of {@link mediaTrimEndAbsoluteMs}: convert the absolute end position
+ * a user typed back into `p14:trim/@end`'s distance-from-tail ms. An end at or
+ * past the clip's tail (or an unknown duration) stores `0`, "no end trim".
+ */
+export declare function mediaTrimEndMsFromAbsoluteMs(durationMs: number, absoluteEndMs: number): number;
+/**
+ * Validate a trim range. `durationMs` of 0 means "unknown" and skips the bound
+ * checks (and, because the end position is only known relative to the tail,
+ * the start-before-end check too).
+ */
+export declare function validateMediaTrimRange(trimStartMs: number, trimEndMs: number, durationMs: number): MediaTrimRangeError | null;
+/**
+ * Effective trimmed playback length in ms. Falls back to the full duration
+ * when the range is empty, inverted, or the duration is unknown.
+ */
+export declare function trimmedMediaDurationMs(trimStartMs: number, trimEndMs: number, durationMs: number): number;
+//# sourceMappingURL=media-trim-range.d.ts.map

package/dist/pptx/render/media-trim-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-trim-range.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-trim-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAElF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKpF;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAK9F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAChB,mBAAmB,GAAG,IAAI,CAW5B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAChB,MAAM,CASR"}

package/dist/pptx/render/media-trim-timeline.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Trim-timeline geometry math for the trim-editing UI, shared by every
+ * binding's trim scrubber (React `TrimTimeline`, Vue `MediaTrimTimeline.vue`,
+ * Angular `media-trim-timeline.component.ts`, Svelte, vanilla).
+ *
+ * `trimEndMs` throughout this module is `p14:trim/@end`'s own on-the-wire
+ * unit: the distance, in milliseconds, from the END of the clip, NOT an
+ * absolute stop time. COM-verified ground truth (see
+ * `PptxHandlerRuntimeMediaParsingUtils.ts`'s `MediaExtensionData` doc):
+ * setting `Shape.MediaFormat.EndPoint = 29596` on a 30034ms clip round-trips
+ * through real PowerPoint as `p14:trim end="438"` (30034 - 29596). Every
+ * function here converts to/from an absolute position internally using the
+ * caller-supplied `durationSeconds`, so a caller can keep storing and
+ * round-tripping the raw distance-from-end value without doing that maths
+ * itself.
+ */
+export type MediaTrimHandle = 'start' | 'end';
+export interface MediaTimelineGeometry {
+    startPercent: number;
+    endPercent: number;
+    playheadPercent: number;
+}
+export interface MediaTrimRange {
+    trimStartMs: number;
+    /** Distance, in ms, from the clip's END. See module doc. */
+    trimEndMs: number;
+}
+export declare function formatMediaTime(seconds: number): string;
+/**
+ * Absolute trim-end position, in seconds, for a `trimEndMs` distance-from-tail
+ * value. `0` (or a negative/unset value) means "play to the end of the clip".
+ * The single place every binding's trim label and range validation should
+ * derive the end position from, so none of them re-reads `trimEndMs` as if it
+ * were an absolute stop time.
+ */
+export declare function mediaTrimEndSeconds(durationSeconds: number, trimEndMs: number): number;
+/**
+ * Inverse of {@link mediaTrimEndSeconds}: convert an absolute end position
+ * (seconds) back to `p14:trim/@end`'s distance-from-tail milliseconds.
+ */
+export declare function mediaTrimEndMsFromSeconds(durationSeconds: number, endSeconds: number): number;
+export declare function mediaTimeFromPointer(clientX: number, barLeft: number, barWidth: number, durationSeconds: number): number;
+export declare function mediaTimelineGeometry(durationSeconds: number, trimStartMs: number, trimEndMs: number, currentTimeSeconds: number): MediaTimelineGeometry;
+export declare function mediaTrimRangeForDrag(handle: MediaTrimHandle, pointerTimeSeconds: number, durationSeconds: number, trimStartMs: number, trimEndMs: number, minimumGapSeconds?: number): MediaTrimRange;
+//# sourceMappingURL=media-trim-timeline.d.ts.map

package/dist/pptx/render/media-trim-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-trim-timeline.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-trim-timeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,qBAAqB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;CAClB;AAMD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGtF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG7F;AAED,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,GACrB,MAAM,CAKR;AAED,wBAAgB,qBAAqB,CACpC,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,GACxB,qBAAqB,CAWvB;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,eAAe,EACvB,kBAAkB,EAAE,MAAM,EAC1B,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,iBAAiB,SAAM,GACrB,cAAc,CAmBhB"}

package/dist/pptx/render/merge-shapes/element-outline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * An element's filled outline as polygon loops in SLIDE coordinates, the input
+ * the Merge Shapes boolean works on.
+ *
+ * The geometry is the same one the renderers paint: custom geometry through
+ * `resolveLiveCustomGeometryPath` (or the structured `customGeometryPaths` a
+ * freeform carries), presets through core's `evaluatePresetShape`, and a
+ * plain rectangle for a text box. Curves are flattened, then the element's
+ * flips and rotation are applied about its centre, the way `a:xfrm` applies
+ * them, so a rotated shape merges where it is drawn rather than where its
+ * unrotated box would be.
+ *
+ * @module render/merge-shapes/element-outline
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { PolygonLoop } from './polygon-types.js';
+/** Samples per full curve when flattening; enough for a smooth merged ellipse. */
+export declare const MERGE_CURVE_SEGMENTS = 24;
+/**
+ * The element's filled area as loops in slide pixels (even-odd), or an empty
+ * list for a stroke-only geometry such as a line or an open arc.
+ */
+export declare function elementOutlineLoops(el: PptxElement, curveSegments?: number): PolygonLoop[];
+//# sourceMappingURL=element-outline.d.ts.map

package/dist/pptx/render/merge-shapes/element-outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-outline.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/element-outline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AASnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AA0CvC;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,EAAE,EAAE,WAAW,EACf,aAAa,SAAuB,GAClC,WAAW,EAAE,CA+Bf"}

package/dist/pptx/render/merge-shapes/index.d.ts

@@ -0,0 +1,6 @@
+export * from './element-outline.js';
+export * from './merge-shapes.js';
+export * from './merge-shapes-menu.js';
+export * from './polygon-boolean.js';
+export * from './polygon-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pptx/render/merge-shapes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dist/pptx/render/merge-shapes/merge-shapes-menu.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The Merge Shapes menu as data: one entry per operation with its i18n key and
+ * the context-menu command id it answers to, so the ribbon dropdown and the
+ * right-click entries in all five bindings list the same operations in the
+ * same order under the same names.
+ *
+ * @module render/merge-shapes/merge-shapes-menu
+ */
+import type { MergeShapeOperation } from 'ooxml-core/pptx';
+/** The right-click command id for each operation. */
+export type MergeShapesCommandId = 'merge-union' | 'merge-combine' | 'merge-fragment' | 'merge-intersect' | 'merge-subtract';
+/** One Merge Shapes menu entry. */
+export interface MergeShapesMenuItem {
+    operation: MergeShapeOperation;
+    /** Ribbon dropdown label key ("Union"). */
+    labelKey: string;
+    /** Context-menu label key ("Union Shapes"). */
+    contextMenuLabelKey: string;
+    commandId: MergeShapesCommandId;
+}
+/** The ribbon button's own label key ("Merge Shapes"). */
+export declare const MERGE_SHAPES_LABEL_KEY = "pptx.shape.mergeShapes";
+/** Tooltip shown while the button is disabled. */
+export declare const MERGE_SHAPES_HINT_KEY = "pptx.shape.mergeShapesHint";
+/** The five operations in PowerPoint's order. */
+export declare const MERGE_SHAPES_MENU_ITEMS: readonly MergeShapesMenuItem[];
+/** The operation a context-menu command runs, or null when it is not a merge command. */
+export declare function mergeOperationForCommand(commandId: string): MergeShapeOperation | null;
+//# sourceMappingURL=merge-shapes-menu.d.ts.map

package/dist/pptx/render/merge-shapes/merge-shapes-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-shapes-menu.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/merge-shapes-menu.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAI3D,qDAAqD;AACrD,MAAM,MAAM,oBAAoB,GAC7B,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,CAAC;AAEpB,mCAAmC;AACnC,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,oBAAoB,CAAC;CAChC;AAED,0DAA0D;AAC1D,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAE/D,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,+BAA+B,CAAC;AAUlE,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,EAAE,SAAS,mBAAmB,EAOjE,CAAC;AAEF,yFAAyF;AACzF,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAEtF"}

package/dist/pptx/render/merge-shapes/merge-shapes.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Merge Shapes (Shape Format > Merge Shapes): Union, Combine, Fragment,
+ * Intersect and Subtract, as one pure planning function every binding calls.
+ *
+ * PowerPoint's rules, reproduced here:
+ * - Two or more shapes (autoshapes, freeforms, text boxes) are required.
+ * - The result is a freeform (`a:custGeom`) that takes the FIRST-selected
+ *   shape's formatting and text; Fragment gives every piece that formatting.
+ * - Subtract removes every other shape from the first-selected one.
+ * - The result sits where the first-selected shape sat in the z-order.
+ * - An operation that leaves nothing (Intersect of disjoint shapes) is a no-op.
+ *
+ * The binding applies the returned plan with {@link applyMergeShapesPlan} in
+ * ONE history step and selects `plan.created`.
+ *
+ * @module render/merge-shapes/merge-shapes
+ */
+import type { MergeShapeOperation, PptxElement, ShapePptxElement } from 'ooxml-core/pptx';
+export type { MergeShapeOperation } from 'ooxml-core/pptx';
+/** PowerPoint's menu order. */
+export declare const MERGE_SHAPE_OPERATIONS: readonly MergeShapeOperation[];
+/** Element types PowerPoint lets you merge: autoshapes, freeforms, text boxes. */
+export declare function isMergeableElement(el: PptxElement | null | undefined): boolean;
+/** Whether Merge Shapes is available for this selection (two or more mergeable shapes). */
+export declare function canMergeShapes(selected: readonly (PptxElement | null | undefined)[]): boolean;
+/** What a merge does to the slide: which elements go, which new ones come. */
+export interface MergeShapesPlan {
+    operation: MergeShapeOperation;
+    /** Ids of the merged source elements, all of which are removed. */
+    removedIds: string[];
+    /** The first-selected source, whose z-position the result takes. */
+    primaryId: string;
+    /** The new freeform shape(s), in paint order. */
+    created: ShapePptxElement[];
+}
+export interface MergeShapesOptions {
+    /** Id factory for the new shapes (defaults to core's `createEditorId`). */
+    createId?: () => string;
+}
+/**
+ * Plan `operation` over `selected` (in SELECTION order: the first entry is the
+ * shape whose formatting survives). Non-mergeable entries are ignored. Returns
+ * null when fewer than two shapes qualify or the result is empty.
+ */
+export declare function planMergeShapes(operation: MergeShapeOperation, selected: readonly PptxElement[], options?: MergeShapesOptions): MergeShapesPlan | null;
+/**
+ * The slide's element list after `plan`: the sources removed and the new
+ * shapes inserted where the first-selected source was.
+ */
+export declare function applyMergeShapesPlan(elements: readonly PptxElement[], plan: MergeShapesPlan): PptxElement[];
+//# sourceMappingURL=merge-shapes.d.ts.map

package/dist/pptx/render/merge-shapes/merge-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-shapes.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/merge-shapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAGX,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAChB,MAAM,iBAAiB,CAAC;AASzB,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,+BAA+B;AAC/B,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAMhE,CAAC;AAEF,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAK9E;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,OAAO,CAW7F;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,mBAAmB,CAAC;IAC/B,mEAAmE;IACnE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC;CACxB;AAyFD;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,OAAO,GAAE,kBAAuB,GAC9B,eAAe,GAAG,IAAI,CAkBxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,IAAI,EAAE,eAAe,GACnB,WAAW,EAAE,CAWf"}

package/dist/pptx/render/merge-shapes/polygon-arrangement.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The planar arrangement behind {@link booleanRegions}: every edge of every
+ * input loop, split at every point where it meets another edge, with coincident
+ * vertices merged and duplicate edges collapsed.
+ *
+ * Splitting first and classifying afterwards is what makes the boolean robust
+ * where the older Sutherland-Hodgman path in core was not: a concave clip, a
+ * shared edge, a hole, a vertex touching an edge are all just edges of the
+ * arrangement, each classified on its own by sampling either side of it.
+ *
+ * @module render/merge-shapes/polygon-arrangement
+ */
+import type { PolygonLoop, PolygonPoint } from './polygon-types.js';
+/** One edge of the arrangement between two canonical vertex indices. */
+export interface ArrangementEdge {
+    from: number;
+    to: number;
+}
+/** Canonical vertices plus the undirected, de-duplicated edges between them. */
+export interface Arrangement {
+    vertices: PolygonPoint[];
+    edges: ArrangementEdge[];
+    /** Largest bounding-box dimension of the input; every tolerance scales from it. */
+    scale: number;
+}
+/** Build the arrangement of every loop in `regions`. */
+export declare function buildArrangement(regions: readonly (readonly PolygonLoop[])[]): Arrangement;
+//# sourceMappingURL=polygon-arrangement.d.ts.map

package/dist/pptx/render/merge-shapes/polygon-arrangement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-arrangement.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/polygon-arrangement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEjE,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACX;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC3B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;CACd;AAoID,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,GAAG,WAAW,CAkC1F"}

package/dist/pptx/render/merge-shapes/polygon-boolean.d.ts

@@ -0,0 +1,21 @@
+import type { PolygonLoop, PolygonPoint, PolygonRegion } from './polygon-types.js';
+/** The four binary set operations. Combine is `xor`. */
+export type PolygonBooleanOp = 'union' | 'intersect' | 'subtract' | 'xor';
+/** Drop vertices that sit on the straight line between their neighbours. */
+export declare function simplifyLoop(loop: readonly PolygonPoint[], tol: number): PolygonLoop;
+/**
+ * `a <op> b`. Inputs are read even-odd; the result is oriented inside-left
+ * (see `./polygon-types`). An empty array means an empty result.
+ */
+export declare function booleanRegions(op: PolygonBooleanOp, a: readonly PolygonLoop[], b: readonly PolygonLoop[]): PolygonRegion;
+/** Total filled area of an inside-left oriented region (holes subtract). */
+export declare function regionArea(region: readonly PolygonLoop[]): number;
+/** Re-orient an even-odd region inside-left by unioning it with nothing. */
+export declare function normalizeRegion(region: readonly PolygonLoop[]): PolygonRegion;
+/**
+ * Split an inside-left region into its connected pieces: each outer loop plus
+ * the holes directly inside it. Fragment uses this so two disjoint leftovers
+ * become two shapes, as PowerPoint makes them.
+ */
+export declare function splitRegionComponents(region: readonly PolygonLoop[]): PolygonRegion[];
+//# sourceMappingURL=polygon-boolean.d.ts.map

package/dist/pptx/render/merge-shapes/polygon-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-boolean.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/polygon-boolean.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhF,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC;AAyF1E,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAyBpF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,EAAE,EAAE,gBAAgB,EACpB,CAAC,EAAE,SAAS,WAAW,EAAE,EACzB,CAAC,EAAE,SAAS,WAAW,EAAE,GACvB,aAAa,CAgCf;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAEjE;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,aAAa,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,aAAa,EAAE,CA4BrF"}

package/dist/pptx/render/merge-shapes/polygon-types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Plain polygon types for the Merge Shapes boolean engine.
+ *
+ * A region is a list of closed loops read with the even-odd rule on input.
+ * Every region the engine RETURNS is additionally oriented so its inside lies
+ * to the left of each edge (outer loops have positive signed area, holes
+ * negative), which makes even-odd and non-zero fills agree on it.
+ *
+ * @module render/merge-shapes/polygon-types
+ */
+/** A 2D point in slide pixels. */
+export interface PolygonPoint {
+    x: number;
+    y: number;
+}
+/** One closed loop; the closing edge back to the first point is implicit. */
+export type PolygonLoop = PolygonPoint[];
+/** A filled area: a set of loops (outer boundaries and holes). */
+export type PolygonRegion = PolygonLoop[];
+/** Shoelace signed area; positive when the inside is on the left of each edge. */
+export declare function signedLoopArea(loop: readonly PolygonPoint[]): number;
+/** Even-odd point-in-region test (ray casting against every loop). */
+export declare function isPointInRegion(p: PolygonPoint, loops: readonly PolygonLoop[]): boolean;
+/** Axis-aligned bounds of a set of loops, or null when there are no points. */
+export declare function polygonRegionBounds(loops: readonly PolygonLoop[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+//# sourceMappingURL=polygon-types.d.ts.map

package/dist/pptx/render/merge-shapes/polygon-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-types.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/merge-shapes/polygon-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,kCAAkC;AAClC,MAAM,WAAW,YAAY;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC;AAEzC,kEAAkE;AAClE,MAAM,MAAM,aAAa,GAAG,WAAW,EAAE,CAAC;AAE1C,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAQpE;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAYvF;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,SAAS,WAAW,EAAE,GAC3B;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiBhE"}

package/dist/pptx/render/mobile-chrome.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pure helper logic for mobile chrome state, shared by every binding.
+ *
+ * These helpers capture the sheet open/close state machine that governs which
+ * sheet is visible at any given time and which bottom-bar button appears active.
+ * Keeping this logic as pure functions makes it straightforward to test and
+ * trivial to adapt when each binding wires the components together.
+ */
+/** All mobile sheets that can be open at one time. */
+export type MobileSheetKey = 'slides' | 'menu' | 'insert' | 'inspector' | 'comments' | 'notes' | null;
+/**
+ * Compute the next sheet state when a bar button is tapped.
+ *
+ * Rules:
+ *   - Tapping the already-open sheet closes it (returns `null`).
+ *   - Tapping a different sheet opens it (and implicitly closes the other).
+ */
+export declare function toggleSheet(current: MobileSheetKey, tapped: Exclude<MobileSheetKey, null>): MobileSheetKey;
+/** Lightweight descriptor for a visible action. */
+export interface ActionDescriptor {
+    key: string;
+    label: string;
+    disabled: boolean;
+}
+/**
+ * Build the ordered list of visible bottom-bar action descriptors given the
+ * current presentation state.
+ *
+ * The list is always the same five slots (Slides, Insert, Format, Comments,
+ * Notes); only `disabled` changes. This makes it easy to iterate in tests
+ * without spinning up a framework.
+ */
+export declare function buildBarActions(opts: {
+    slideCount: number;
+}): ActionDescriptor[];
+/**
+ * Return the sheet that should be open after the user navigates to a new slide
+ * via the bottom bar prev/next buttons.
+ *
+ * Convention: navigation does NOT close the slides sheet (the user may want to
+ * browse thumbnails while paging), but it DOES close the menu sheet (which is
+ * an interruption).
+ */
+export declare function sheetAfterNavigate(current: MobileSheetKey): MobileSheetKey;
+//# sourceMappingURL=mobile-chrome.d.ts.map

package/dist/pptx/render/mobile-chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-chrome.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/mobile-chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,sDAAsD;AACtD,MAAM,MAAM,cAAc,GACvB,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,WAAW,GACX,UAAU,GACV,OAAO,GACP,IAAI,CAAC;AAMR;;;;;;GAMG;AACH,wBAAgB,WAAW,CAC1B,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,GACnC,cAAc,CAEhB;AAMD,mDAAmD;AACnD,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,gBAAgB,EAAE,CAWhF;AAMD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAE1E"}

package/dist/pptx/render/mobile-keyboard.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Framework-agnostic virtual-keyboard inset maths shared by the React, Vue, and
+ * Angular bindings. On a touch device the on-screen keyboard shrinks the
+ * `VisualViewport` (its `height`) without changing the layout viewport
+ * (`window.innerHeight`). The difference is how many CSS pixels the keyboard
+ * covers at the bottom of the screen.
+ *
+ * Each binding wires a tiny `visualViewport` `resize` listener and feeds the
+ * live measurements through {@link computeKeyboardInset} and
+ * {@link computeScrollDelta}; the pure maths lives here so every binding keeps
+ * the focused field visible identically (and is unit-testable without a DOM).
+ */
+/**
+ * Below this many covered CSS pixels we treat the keyboard as closed. URL-bar
+ * collapse / browser-chrome jitter routinely shrinks the visual viewport by a
+ * few dozen pixels; a real on-screen keyboard covers far more (typically
+ * 250px+), so this threshold rejects the noise without missing a real keyboard.
+ */
+export declare const KEYBOARD_OPEN_THRESHOLD = 120;
+/** A snapshot of the layout + visual viewport, as numbers (DOM-free). */
+export interface ViewportMetrics {
+    /** Layout-viewport height, i.e. `window.innerHeight` (CSS px). */
+    layoutHeight: number;
+    /** Visual-viewport height, i.e. `visualViewport.height` (CSS px). */
+    visualHeight: number;
+    /** Visual-viewport top offset, i.e. `visualViewport.offsetTop` (CSS px). */
+    offsetTop: number;
+}
+/**
+ * Compute how many CSS pixels the on-screen keyboard covers at the bottom of
+ * the layout viewport.
+ *
+ * The visible region spans `[offsetTop, offsetTop + visualHeight]` inside the
+ * layout viewport `[0, layoutHeight]`; whatever sits below the visible region
+ * is covered by the keyboard (and/or the collapsed browser chrome):
+ *
+ *   inset = layoutHeight - (visualHeight + offsetTop)
+ *
+ * Clamped to `>= 0` and rounded. Returns `0` for non-finite or zero inputs so a
+ * missing `VisualViewport` (desktop, SSR, old browsers) reports "no keyboard".
+ */
+export declare function computeKeyboardInset(m: ViewportMetrics): number;
+/** Whether a given keyboard inset (CSS px) is large enough to count as "open". */
+export declare function isKeyboardOpen(inset: number, threshold?: number): boolean;
+/**
+ * Read the live viewport metrics from `window`/`visualViewport`. Returns `null`
+ * when neither is available (SSR / non-DOM test), so callers can skip wiring.
+ */
+export declare function readViewportMetrics(win?: Window | undefined): ViewportMetrics | null;
+/** A rectangle's vertical extent in layout-viewport CSS pixels. */
+export interface VerticalRect {
+    /** Distance from the top of the layout viewport to the rect's top edge. */
+    top: number;
+    /** Distance from the top of the layout viewport to the rect's bottom edge. */
+    bottom: number;
+}
+/**
+ * Given the focused element's vertical rect (relative to the layout viewport),
+ * the layout-viewport height, and the keyboard inset, compute how far the page
+ * must scroll (delta in CSS px) to bring the rect fully inside the area NOT
+ * covered by the keyboard. Positive = scroll down (content up); negative =
+ * scroll up. `0` means already visible.
+ *
+ * @param margin - Extra breathing room (CSS px) to keep above the keyboard / below
+ *                 the top edge so the field is not flush against the boundary.
+ */
+export declare function computeScrollDelta(rect: VerticalRect, layoutHeight: number, keyboardInset: number, margin?: number): number;
+//# sourceMappingURL=mobile-keyboard.d.ts.map

package/dist/pptx/render/mobile-keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-keyboard.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/mobile-keyboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC/B,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAgB/D;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAgC,GACzC,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,GAAE,MAAM,GAAG,SAA8D,GAC1E,eAAe,GAAG,IAAI,CAaxB;AAED,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC5B,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,MAAW,GACjB,MAAM,CAYR"}

package/dist/pptx/render/mobile-viewport.d.ts

@@ -0,0 +1,69 @@
+/**
+ * mobile-viewport.ts: framework-agnostic viewport / touch / orientation
+ * detection shared by the React, Vue, and Angular bindings.
+ *
+ * These are the pure predicates and feature-detection helpers behind each
+ * binding's `useIsMobile` / `IsMobileService`. The reactive wiring (React
+ * state, Vue refs, Angular signals) stays in the binding; the breakpoint maths
+ * and DOM capability probes live here so all three frameworks switch chrome at
+ * exactly the same thresholds.
+ *
+ * SSR / test safe: every probe feature-detects `window` / `navigator` /
+ * `screen` and returns a sensible default when absent.
+ */
+/** Mobile breakpoint: below this width is considered mobile. */
+export declare const MOBILE_BREAKPOINT = 768;
+/** Tablet breakpoint: below this width (but >= MOBILE) is tablet. */
+export declare const TABLET_BREAKPOINT = 1024;
+/**
+ * Max viewport height (px) at which a *touch* device is treated as mobile
+ * regardless of width. Catches landscape phones (e.g. 915x412), which are wide
+ * enough to fall in the "tablet" width band but far too short for the desktop
+ * ribbon + side panels, so they need the mobile chrome. Tablets in landscape
+ * are taller (~760px+) so they stay on the desktop layout.
+ */
+export declare const MOBILE_LANDSCAPE_MAX_HEIGHT = 500;
+/** Device orientation as reported by the screen / viewport aspect ratio. */
+export type DeviceOrientation = 'portrait' | 'landscape';
+/**
+ * Whether a viewport should use the mobile layout: a narrow viewport, OR a
+ * short touch viewport below the tablet width (a landscape phone, which is wide
+ * enough to look like a tablet but far too short for the desktop ribbon).
+ *
+ * @pure: no side effects, fully testable without a DOM.
+ */
+export declare function isMobileViewport(width: number, height: number, isTouch: boolean): boolean;
+/**
+ * Whether a width is in the "tablet" band (desktop chrome, 768..1023px wide).
+ * Width-only: callers that need the "short landscape phone is mobile, not
+ * tablet" carve-out should gate this with `!isMobileViewport(...)` first.
+ *
+ * @pure
+ */
+export declare function isTabletViewport(width: number): boolean;
+/** The three mutually-exclusive chrome tiers a viewer can render. */
+export interface ViewportBreakpoints {
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+}
+/**
+ * Classify a viewport into the mobile/tablet/desktop chrome tiers.
+ *
+ * The measurement MUST be the browser viewport (`window.innerWidth` /
+ * `innerHeight`), never an embedded container's box. A viewer hosted in a
+ * narrow sidebar or split pane still has a full desktop pointer and keyboard;
+ * measuring its container instead of the viewport made React and Vue swap in
+ * the touch-oriented mobile bottom-sheet UI for a mouse-driven desktop host,
+ * while Angular, Svelte and Vanilla (already viewport-based) did not. The
+ * container itself may still be measured separately for layout/canvas
+ * fitting - that is an unrelated concern from chrome selection.
+ *
+ * @pure
+ */
+export declare function deriveViewportBreakpoints(width: number, height: number, isTouch: boolean): ViewportBreakpoints;
+/** Whether the current runtime reports touch capability. */
+export declare function detectTouchDevice(): boolean;
+/** Current device orientation from `screen.orientation` or the viewport aspect. */
+export declare function detectOrientation(): DeviceOrientation;
+//# sourceMappingURL=mobile-viewport.d.ts.map

package/dist/pptx/render/mobile-viewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-viewport.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/mobile-viewport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,WAAW,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAKzF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,GACd,mBAAmB,CAIrB;AAED,4DAA4D;AAC5D,wBAAgB,iBAAiB,IAAI,OAAO,CAgB3C;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,IAAI,iBAAiB,CAQrD"}

package/dist/pptx/render/modal-focus.d.ts

@@ -0,0 +1,16 @@
+/** Framework-neutral keyboard focus management for modal dialogs. */
+export { MODAL_FOCUSABLE_SELECTOR, modalActiveElement, modalFocusableElements, } from '../../dialog/focus.js';
+export interface ModalFocusOptions {
+    /** Element that should receive initial focus. Defaults to the first control. */
+    initialFocus?: HTMLElement | null;
+    /** Invoked after Escape is consumed. */
+    onEscape?: () => void;
+    /** Restore focus to the opener when the manager is released. */
+    restoreFocus?: boolean;
+}
+/**
+ * Moves focus into a modal, traps Tab within it, handles Escape, and returns
+ * focus to the opener on cleanup. The caller owns visibility and teardown.
+ */
+export declare function activateModalFocus(panel: HTMLElement, options?: ModalFocusOptions): () => void;
+//# sourceMappingURL=modal-focus.d.ts.map

package/dist/pptx/render/modal-focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-focus.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/modal-focus.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAMrE,OAAO,EACN,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,iBAAiB;IACjC,gFAAgF;IAChF,YAAY,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAcD;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE,iBAAsB,GAC7B,MAAM,IAAI,CAmEZ"}