ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/collaboration-text-session.d.ts

@@ -0,0 +1,3 @@
+export { createCollaborationTextSession } from 'ooxml-core/pptx/editor/render/collaboration-text-session';
+export type { TextSessionPositions, CollaborationTextSnapshot, CollaborationTextSession, } from 'ooxml-core/pptx/editor/render/collaboration-text-session';
+//# sourceMappingURL=collaboration-text-session.d.ts.map

package/dist/pptx/render/collaboration-text-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration-text-session.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/collaboration-text-session.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0DAA0D,CAAC;AAC1G,YAAY,EACX,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,GACxB,MAAM,0DAA0D,CAAC"}

package/dist/pptx/render/collaboration-text-snapshot-positions.d.ts

@@ -0,0 +1,3 @@
+export { createSnapshotTextPositions } from 'ooxml-core/pptx/editor/render/collaboration-text-snapshot-positions';
+export type { TextPositionSnapshots, SnapshotText, } from 'ooxml-core/pptx/editor/render/collaboration-text-snapshot-positions';
+//# sourceMappingURL=collaboration-text-snapshot-positions.d.ts.map

package/dist/pptx/render/collaboration-text-snapshot-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration-text-snapshot-positions.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/collaboration-text-snapshot-positions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qEAAqE,CAAC;AAClH,YAAY,EACX,qBAAqB,EACrB,YAAY,GACZ,MAAM,qEAAqE,CAAC"}

package/dist/pptx/render/collaboration-text-target.d.ts

@@ -0,0 +1,30 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { YDocLike, YjsFactories } from './collaboration-sync.js';
+import type { CollaborationTextSession, CollaborationTextSnapshot } from './collaboration-text-session.js';
+import type { InlineTextEditSnapshot } from './inline-list-types.js';
+export interface CollaborationInlineSnapshot extends CollaborationTextSnapshot {
+    readonly inline: InlineTextEditSnapshot;
+}
+/** A mounted editor owns this handle, never the document or its provider. */
+export interface CollaborationTextTarget extends CollaborationTextSession {
+    readMerged: () => CollaborationInlineSnapshot | undefined;
+    /** A bookmark follows character identity rather than a mutable numeric offset. */
+    bookmark: (index: number, association: number) => () => number | null;
+}
+/**
+ * Bind a native text session to an exact live element. Replacing the element,
+ * text, document, or write permission retires it, including reentrant changes
+ * made by a host's beforeTransaction listener.
+ */
+export declare function createCollaborationTextTarget({ doc, factories, slideId, elementId, isWritable, onChange, ownsModel, }: {
+    doc: YDocLike;
+    factories: YjsFactories;
+    slideId: string | undefined;
+    elementId: string;
+    isWritable: () => boolean;
+    /** The caller reads and acknowledges a snapshot only after painting it. */
+    onChange?: () => void;
+    /** Native controller retires synchronously before explicit model changes reconcile. */
+    ownsModel?: (element: PptxElement) => boolean;
+}): CollaborationTextTarget | undefined;
+//# sourceMappingURL=collaboration-text-target.d.ts.map

package/dist/pptx/render/collaboration-text-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration-text-target.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/collaboration-text-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,iBAAiB,CAAC;AAIhE,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOnE,OAAO,KAAK,EACX,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC7E,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;CACxC;AAED,6EAA6E;AAC7E,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACxE,UAAU,EAAE,MAAM,2BAA2B,GAAG,SAAS,CAAC;IAC1D,kFAAkF;IAClF,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,MAAM,MAAM,GAAG,IAAI,CAAC;CACtE;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,EAC7C,GAAG,EACH,SAAS,EACT,OAAO,EACP,SAAS,EACT,UAAU,EACV,QAAQ,EACR,SAAS,GACT,EAAE;IACF,GAAG,EAAE,QAAQ,CAAC;IACd,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,uFAAuF;IACvF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;CAC9C,GAAG,uBAAuB,GAAG,SAAS,CA4FtC"}

package/dist/pptx/render/collaboration-writeback.d.ts

@@ -0,0 +1,42 @@
+import type { PptxElement, PptxHandlerSaveOptions, PptxSlide } from 'ooxml-core/pptx';
+import type { CollaborationConfig } from '../types.js';
+import type { YDocLike } from './collaboration-sync.js';
+export interface WriteBackDeps {
+    /** The live Y.Doc, or null when disconnected. */
+    getYDoc: () => YDocLike | null;
+    /** Reuse a binding's retained serializer, with cancellation checks between awaits. */
+    serialize?: (isCurrent: () => boolean) => Promise<Uint8Array | null> | Uint8Array | null;
+    /** The retained source PPTX bytes to reload before overlaying Y.Doc slides. */
+    getSourceBytes?: () => Uint8Array | null;
+    /** The per-slide master/layout template element store to merge back. */
+    getTemplateElements?: () => Record<string, PptxElement[]>;
+    /**
+     * Merge template (master/layout) elements back into the broadcast
+     * (template-free) slides before saving. Defaults to a passthrough that
+     * ignores `getTemplateElements` when omitted, for bindings without
+     * template-mode editing.
+     */
+    mergeTemplateElements?: (slides: PptxSlide[], templateElements: Record<string, PptxElement[]>) => PptxSlide[];
+    /**
+     * Session-level save options (view properties, table styles, tags, deck
+     * properties, ...) to persist alongside the Y.Doc slides, built the same
+     * way as the binding's own Save/Export path (`buildDeckSaveOptions` in
+     * `render/deck-save-options`). Without this the write-back reloaded the
+     * source bytes and called `handler.save(merged)` with NO options, so an
+     * owner's write-back file silently dropped every session-level edit that
+     * lives outside `slides` (table style edits, view toggles, tags, deck
+     * properties, ...) even though those edits were visible on screen and
+     * would have been saved by a manual Ctrl+S. Omitted for a binding that has
+     * not wired it yet, which reproduces the pre-existing (options-less) save.
+     */
+    getSaveOptions?: () => PptxHandlerSaveOptions | undefined;
+}
+export type WriteBackConfig = Pick<CollaborationConfig, 'role' | 'onWriteBack' | 'writeBackDebounceMs' | 'externalSession'>;
+export interface WriteBackScheduler {
+    /** Debounce a write-back for the given session (no-op unless role 'owner'). */
+    schedule: (config: WriteBackConfig) => void;
+    /** Cancel any pending write-back. */
+    cancel: () => void;
+}
+export declare function createWriteBackScheduler(deps: WriteBackDeps): WriteBackScheduler;
+//# sourceMappingURL=collaboration-writeback.d.ts.map

package/dist/pptx/render/collaboration-writeback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration-writeback.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/collaboration-writeback.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKrD,MAAM,WAAW,aAAa;IAC7B,iDAAiD;IACjD,OAAO,EAAE,MAAM,QAAQ,GAAG,IAAI,CAAC;IAC/B,sFAAsF;IACtF,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,OAAO,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,UAAU,GAAG,IAAI,CAAC;IACzF,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IACzC,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IAC1D;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,CACvB,MAAM,EAAE,SAAS,EAAE,EACnB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,KAC3C,SAAS,EAAE,CAAC;IACjB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,MAAM,sBAAsB,GAAG,SAAS,CAAC;CAC1D;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CACjC,mBAAmB,EACnB,MAAM,GAAG,aAAa,GAAG,qBAAqB,GAAG,iBAAiB,CAClE,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,+EAA+E;IAC/E,QAAQ,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IAC5C,qCAAqC;IACrC,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,GAAG,kBAAkB,CAmFhF"}

package/dist/pptx/render/color-contrast.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: the implementation lives in ooxml-core/color (`contrast.ts`). */
+export { parseHex, contrastTextColor } from 'ooxml-core/color';
+//# sourceMappingURL=color-contrast.d.ts.map

package/dist/pptx/render/color-contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-contrast.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/color-contrast.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/pptx/render/color-swatches.d.ts

@@ -0,0 +1,2 @@
+export * from '../../form/color-swatches.js';
+//# sourceMappingURL=color-swatches.d.ts.map

package/dist/pptx/render/color-swatches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-swatches.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/color-swatches.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/pptx/render/color-units.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: the implementation lives in ooxml-core/color (`unit-rgb.ts`). */
+export { hexToRgbUnit } from 'ooxml-core/color';
+//# sourceMappingURL=color-units.d.ts.map

package/dist/pptx/render/color-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-units.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/color-units.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/pptx/render/command-search.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Command-search data for the PowerPoint-style "Tell me what you want to do"
+ * search bar. Provides searchable command entries grouped by category, each
+ * mapping a label translation key to a command identifier that bindings can
+ * dispatch.
+ */
+export interface CommandSearchEntry {
+    /** Translation key for the display label. */
+    labelKey: string;
+    /** Command identifier dispatched to the host binding. */
+    command: string;
+    /** Optional icon hint (binding resolves to framework icon component). */
+    icon?: string;
+    /** Category grouping key; hosts with their own short list may omit it. */
+    category?: 'format' | 'insert' | 'view' | 'slideShow' | 'design' | 'arrange';
+}
+/**
+ * Static catalogue of searchable commands. Bindings filter this list by the
+ * user's typed query (matching against the resolved translation text).
+ */
+export declare const COMMAND_SEARCH_ENTRIES: readonly CommandSearchEntry[];
+/**
+ * Filter the command catalogue by a search query (case-insensitive substring
+ * match against the resolved label). The `resolveLabel` callback is provided
+ * by the binding to translate the key into the current locale's text.
+ */
+export declare function filterCommands(query: string, resolveLabel: (key: string) => string, entries?: readonly CommandSearchEntry[]): CommandSearchEntry[];
+//# sourceMappingURL=command-search.d.ts.map

package/dist/pptx/render/command-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-search.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/command-search.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,kBAAkB;IAClC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;CAC7E;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,kBAAkB,EAwKtD,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,EACrC,OAAO,GAAE,SAAS,kBAAkB,EAA2B,GAC7D,kBAAkB,EAAE,CAMtB"}

package/dist/pptx/render/comment-markers.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Framework-agnostic canvas comment-marker model.
+ *
+ * Builds the numbered marker-dot descriptors every binding draws over the
+ * slide canvas: the position comes from {@link getCommentMarkerPosition}
+ * (explicit comment x/y clamped to the slide, else a 4-column grid fallback),
+ * the label is the 1-based comment number, and the title is
+ * `"<author>: <text>"`, the neutral hook the cross-binding e2e suite reads.
+ *
+ * No framework imports; each binding renders these descriptors inside its
+ * `aria-roledescription="slide"` stage.
+ */
+import type { PptxComment } from 'ooxml-core/pptx';
+/** Rendered diameter of a marker dot, in unscaled slide px. */
+export declare const COMMENT_MARKER_SIZE = 20;
+/** Marker dot fill shared by every binding (orange, slightly translucent). */
+export declare const COMMENT_MARKER_COLOR = "rgba(255, 165, 0, 0.9)";
+/** One renderable marker dot. */
+export interface CommentMarkerDescriptor {
+    /** Id of the comment the dot represents (click payload). */
+    commentId: string;
+    /** 1-based comment number rendered inside the dot. */
+    label: string;
+    /** Dot CENTER x, in unscaled slide coordinates. */
+    x: number;
+    /** Dot CENTER y, in unscaled slide coordinates. */
+    y: number;
+    /** Tooltip text: `"<author>: <text>"`. */
+    title: string;
+}
+/** The marker tooltip: `"<author>: <text>"`, falling back for blank authors. */
+export declare function commentMarkerTitle(comment: PptxComment, fallbackAuthor: string): string;
+/**
+ * Map a slide's comments to renderable marker descriptors.
+ * @param fallbackAuthor label used in the tooltip when a comment has no author
+ *   (bindings pass their localized "Unknown" string).
+ */
+export declare function buildCommentMarkers(comments: readonly PptxComment[], canvasWidth: number, canvasHeight: number, fallbackAuthor: string): CommentMarkerDescriptor[];
+//# sourceMappingURL=comment-markers.d.ts.map

package/dist/pptx/render/comment-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-markers.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/comment-markers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAE7D,iCAAiC;AACjC,MAAM,WAAW,uBAAuB;IACvC,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,mDAAmD;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;CACd;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GACpB,uBAAuB,EAAE,CAW3B"}

package/dist/pptx/render/comment-mentions.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure, framework-agnostic `@`-mention logic for comment bodies.
+ *
+ * A comment's text is a flat string; its mentions are offset spans into that
+ * string (see `PptxCommentMention`). Every binding needs the same two answers:
+ *
+ * - DISPLAY: "which slices of this string are mentions?" -> `commentTextSegments`
+ *   returns a framework-neutral `CommentTextSegment[]` that a template maps
+ *   straight onto spans.
+ * - AUTHORING: "the user picked an author from the `@` typeahead"
+ *   -> `insertCommentMention` returns the new text, the new mention list, and
+ *   where the caret should land.
+ *
+ * No framework imports.
+ */
+import type { PptxCommentMention, PptxModernCommentAuthor } from 'ooxml-core/pptx';
+/** DOM attribute every binding stamps on a rendered mention, for e2e. */
+export declare const COMMENT_MENTION_ATTRIBUTE = "data-pptx-comment-mention";
+/** CSS class every binding puts on a rendered mention span. */
+export declare const COMMENT_MENTION_CLASS = "pptx-comment-mention";
+/** One run of a comment body: either inert text or an `@`-mention. */
+export interface CommentTextSegment {
+    kind: 'text' | 'mention';
+    text: string;
+    /** Display name of the mentioned author, when it resolved. */
+    authorName?: string;
+    /** `p188:author` id of the mentioned person. */
+    personId?: string;
+}
+/**
+ * Split a comment body into plain-text and mention segments.
+ *
+ * Overlapping, out-of-range and zero-length spans are ignored rather than
+ * producing garbled output, because the offsets come from a foreign file and
+ * an edit made outside this library can invalidate them.
+ */
+export declare function commentTextSegments(text: string, mentions?: PptxCommentMention[]): CommentTextSegment[];
+/** Whether this body has at least one renderable mention. */
+export declare function hasCommentMentions(text: string, mentions?: PptxCommentMention[]): boolean;
+/** An in-progress `@` token the author is typing, for the mention typeahead. */
+export interface CommentMentionQuery {
+    /** Text typed after the `@`, lower-cased for matching. */
+    query: string;
+    /** Index of the `@` itself. */
+    start: number;
+}
+/**
+ * The `@`-token immediately left of `caret`, or `null` when there is none.
+ *
+ * The `@` must start the body or follow whitespace, and the token must not
+ * contain whitespace, so an email address does not open the picker.
+ */
+export declare function commentMentionQuery(text: string, caret: number): CommentMentionQuery | null;
+/** Authors whose name or initials match a typeahead query, best-first. */
+export declare function matchCommentMentionAuthors(authors: PptxModernCommentAuthor[], query: string, limit?: number): PptxModernCommentAuthor[];
+/** Result of accepting an author from the mention typeahead. */
+export interface CommentMentionInsertion {
+    text: string;
+    mentions: PptxCommentMention[];
+    /** Where the caret belongs after the insertion. */
+    caret: number;
+}
+/** A brace-wrapped GUID, the shape `mentionId` uses. */
+export declare function defaultMentionId(): string;
+/**
+ * Replace the `@`-token at `caret` with `@<author name>` and record the mention.
+ *
+ * Existing mentions after the insertion point are shifted by the length delta,
+ * so a body with several mentions stays consistent while it is being typed.
+ * The inserted span INCLUDES the `@`, which is what Office records.
+ */
+export declare function insertCommentMention(text: string, mentions: PptxCommentMention[] | undefined, caret: number, author: PptxModernCommentAuthor, generateId?: () => string): CommentMentionInsertion;
+//# sourceMappingURL=comment-mentions.d.ts.map

package/dist/pptx/render/comment-mentions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-mentions.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/comment-mentions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AAErE,+DAA+D;AAC/D,eAAO,MAAM,qBAAqB,yBAAyB,CAAC;AAE5D,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAcD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,kBAAkB,EAAE,GAC7B,kBAAkB,EAAE,CA0BtB;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAEzF;AAED,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IACnC,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAgB3F;AAgBD,0EAA0E;AAC1E,wBAAgB,0BAA0B,CACzC,OAAO,EAAE,uBAAuB,EAAE,EAClC,KAAK,EAAE,MAAM,EACb,KAAK,SAAI,GACP,uBAAuB,EAAE,CAU3B;AAED,gEAAgE;AAChE,MAAM,WAAW,uBAAuB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,IAAI,MAAM,CAWzC;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kBAAkB,EAAE,GAAG,SAAS,EAC1C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,uBAAuB,EAC/B,UAAU,GAAE,MAAM,MAAyB,GACzC,uBAAuB,CAqBzB"}

package/dist/pptx/render/comments-list.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure, framework-agnostic comment-array transforms, shared by every binding.
+ *
+ * Operates on a single slide's comment list (the "active slide" slice). Each
+ * mutator returns the NEW full comment array, or `null` when nothing changed
+ * (blank text / id-not-found), so the host can write the result back
+ * history-aware.
+ *
+ * No framework imports.
+ */
+import type { PptxComment } from 'ooxml-core/pptx';
+/** Generate a stable, collision-resistant comment id. */
+export declare function generateCommentId(): string;
+/**
+ * Append a new comment to a comment list.
+ * @returns the NEW full comment array, or `null` when `text` is blank.
+ */
+export declare function addCommentToList(comments: PptxComment[], text: string, authorName: string, x?: number, y?: number, elementId?: string): PptxComment[] | null;
+/**
+ * Remove a comment (by id) from a comment list. Searches the whole tree, so
+ * a nested reply (at any depth) is removed just like a top-level comment.
+ * @returns the NEW full comment array, or `null` when nothing changed.
+ */
+export declare function removeCommentFromList(comments: PptxComment[], id: string): PptxComment[] | null;
+/**
+ * Update the text of a comment (by id) anywhere in the tree (top-level rows
+ * and nested `replies`, at any depth).
+ * @returns the NEW full comment array, or `null` when `text` is blank or the
+ *   comment is not found.
+ */
+export declare function editCommentInList(comments: PptxComment[], id: string, text: string): PptxComment[] | null;
+/**
+ * Append a threaded reply under the top-level comment `parentId`.
+ *
+ * The reply is nested inside the parent's `replies` array and stamped with
+ * `threadId`/`parentId` (mirroring React's `handleSubmitReply`), inheriting
+ * the parent's `elementId` anchor when it has one.
+ * @returns the NEW full comment array, or `null` when `text` is blank or the
+ *   parent is not found.
+ */
+export declare function replyToCommentInList(comments: PptxComment[], parentId: string, text: string, authorName: string): PptxComment[] | null;
+/**
+ * Toggle the `resolved` flag of a comment (by id) in a comment list. Searches
+ * the whole tree, so a nested reply (at any depth) can be resolved just like
+ * a top-level comment.
+ * @returns the NEW full comment array, or `null` when nothing changed.
+ */
+export declare function toggleCommentResolvedInList(comments: PptxComment[], id: string): PptxComment[] | null;
+//# sourceMappingURL=comments-list.d.ts.map

package/dist/pptx/render/comments-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comments-list.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/comments-list.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,yDAAyD;AACzD,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,QAAQ,EAAE,WAAW,EAAE,EACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,CAAC,CAAC,EAAE,MAAM,EACV,CAAC,CAAC,EAAE,MAAM,EACV,SAAS,CAAC,EAAE,MAAM,GAChB,WAAW,EAAE,GAAG,IAAI,CAkBtB;AAwDD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,IAAI,CAG/F;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,WAAW,EAAE,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACV,WAAW,EAAE,GAAG,IAAI,CAUtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,WAAW,EAAE,EACvB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GAChB,WAAW,EAAE,GAAG,IAAI,CAuBtB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,WAAW,EAAE,EACvB,EAAE,EAAE,MAAM,GACR,WAAW,EAAE,GAAG,IAAI,CAMtB"}

package/dist/pptx/render/compatibility-warning-toasts.d.ts

@@ -0,0 +1,47 @@
+/**
+ * compatibility-warning-toasts.ts: turn `handler.getCompatibilityWarnings()`
+ * output into the toast list a binding should show.
+ *
+ * Core's `PptxCompatibilityService` (and a handful of save-path modules that
+ * report through it) already flags every markup pattern it silently drops or
+ * approximates: unmodelled OOXML it round-trips only via `rawXml`, an
+ * external image reference that can't be embedded, signatures stripped on
+ * save, a chart's embedded workbook it couldn't write back to, and so on. No
+ * binding read `getCompatibilityWarnings()` at all, so an author saving a
+ * deck that quietly lost fidelity had no way to know from the UI.
+ *
+ * This module is deliberately just a lookup: it does not decide WHEN to call
+ * `getCompatibilityWarnings()` (after load, after save, ...), only how to
+ * turn whatever it returns into toast descriptors with translated copy.
+ *
+ * Framework-agnostic: no React, Vue, Angular, Svelte or DOM imports.
+ */
+/** The `PptxCompatibilityWarning` fields this module reads. Declared structurally. */
+export interface CompatibilityWarningSource {
+    readonly code: string;
+    readonly severity: 'info' | 'warning';
+    readonly slideId?: string;
+    readonly elementId?: string;
+}
+export interface CompatibilityWarningToast {
+    /** Stable per-code id, since toasts are deduped by code (see module docs). */
+    readonly id: string;
+    readonly code: string;
+    readonly severity: 'info' | 'warning';
+    readonly messageKey: string;
+    /** `{{code}}` for the generic fallback key; `undefined` for a mapped code. */
+    readonly params?: Readonly<Record<string, string>>;
+}
+/**
+ * Map `getCompatibilityWarnings()` output to the toast list a binding should
+ * show, deduped by code.
+ *
+ * Core already dedupes exact repeats (same code + scope + ids), but a save
+ * touching fifty images with the same unsupported payload still reports
+ * fifty warnings sharing one code; surfacing fifty identical toasts would be
+ * worse than surfacing none, so this collapses to one toast per code. The
+ * FIRST warning for a code decides that toast's severity, matching how a
+ * user reads a deduped list: the earliest (usually most encompassing) case.
+ */
+export declare function compatibilityWarningToasts(warnings: readonly CompatibilityWarningSource[]): CompatibilityWarningToast[];
+//# sourceMappingURL=compatibility-warning-toasts.d.ts.map

package/dist/pptx/render/compatibility-warning-toasts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility-warning-toasts.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/compatibility-warning-toasts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,sFAAsF;AACtF,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACzC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACnD;AAkDD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,SAAS,0BAA0B,EAAE,GAC7C,yBAAyB,EAAE,CAgB7B"}

package/dist/pptx/render/connector-arrow-controls.d.ts

@@ -0,0 +1,69 @@
+/**
+ * connector-arrow-controls.ts: the inspector's connector arrowhead controls,
+ * described once for every binding.
+ *
+ * WHY this exists: a connector's arrowheads live on `a:ln/a:headEnd` and
+ * `a:ln/a:tailEnd`, each carrying a `type` plus a `w` (width) and `len`
+ * (length) step. That is six editable properties, and every binding that
+ * offered them had re-declared the option order, the fallback values and the
+ * caption keys in its own private table. React, Angular, Svelte and Vanilla had
+ * each written their own, and they had already drifted: two bindings offered
+ * only the two `type` pickers, and one listed the six arrowhead tokens in a
+ * different order. Vue had no arrowhead control at all, so a Vue user could not
+ * change a connector's arrowheads by any route.
+ *
+ * The descriptors below are therefore the single source of truth for WHICH
+ * controls the card shows, in WHICH order, over WHICH tokens. A binding renders
+ * them; it does not restate them. Captions reuse the already-translated
+ * arrowhead / size vocabulary in `schema-label-keys.ts` rather than inventing a
+ * parallel one.
+ *
+ * @module render/connector-arrow-controls
+ */
+import type { ConnectorArrowType, ShapeStyle } from 'ooxml-core/pptx';
+/**
+ * The six arrowhead tokens, in the order PowerPoint's own arrow gallery lists
+ * them (and the order React's picker has always used). `arrow` is PowerPoint's
+ * "Open Arrow"; the spelling comes from `ARROWHEAD_LABEL_KEYS`, never from the
+ * raw token.
+ */
+export declare const CONNECTOR_ARROW_VALUES: readonly ConnectorArrowType[];
+/** The `a:headEnd/@w` and `@len` steps, smallest first. */
+export declare const CONNECTOR_ARROW_SIZE_VALUES: readonly ConnectorArrowSize[];
+/** An arrowhead width / length step. */
+export type ConnectorArrowSize = 'sm' | 'med' | 'lg';
+/** The `ShapeStyle` keys the arrowhead card writes. */
+export type ConnectorArrowStyleKey = 'connectorStartArrow' | 'connectorEndArrow' | 'connectorStartArrowWidth' | 'connectorStartArrowLength' | 'connectorEndArrowWidth' | 'connectorEndArrowLength';
+/** One dropdown on the connector card. */
+export interface ConnectorArrowControl {
+    /** The `ShapeStyle` property this dropdown reads and writes. */
+    readonly styleKey: ConnectorArrowStyleKey;
+    /** i18n key for the dropdown's visible label, which is its accessible name. */
+    readonly labelKey: string;
+    /** Offered tokens, in display order. */
+    readonly values: readonly string[];
+    /** Token to i18n key, for spelling each option. */
+    readonly optionLabelKeys: Readonly<Record<string, string>>;
+    /**
+     * Shown when the style carries nothing. An absent `a:headEnd` means no
+     * arrowhead, while an absent `@w`/`@len` means PowerPoint's default medium.
+     */
+    readonly fallback: string;
+}
+/**
+ * The card's controls, in render order: the two head TYPES first (the property
+ * users reach for), then each end's width and length.
+ */
+export declare const CONNECTOR_ARROW_CONTROLS: readonly ConnectorArrowControl[];
+/** Current token for one control, or its fallback when the style is silent. */
+export declare function connectorArrowValue(control: ConnectorArrowControl, style: ShapeStyle | undefined): string;
+/**
+ * Build the `ShapeStyle` patch for one dropdown change.
+ *
+ * WHY a helper: the six keys hold two different value unions, so writing
+ * `{ [control.styleKey]: raw }` inline forces every binding to widen the value
+ * and cast. Narrowing once here keeps the casts out of the view layer, and
+ * makes an unknown token a no-op rather than a corrupt `shapeStyle`.
+ */
+export declare function connectorArrowPatch(control: ConnectorArrowControl, raw: string): Partial<ShapeStyle>;
+//# sourceMappingURL=connector-arrow-controls.d.ts.map

package/dist/pptx/render/connector-arrow-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-arrow-controls.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-arrow-controls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAItE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,kBAAkB,EAO/D,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,2BAA2B,EAAE,SAAS,kBAAkB,EAAwB,CAAC;AAE9F,wCAAwC;AACxC,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,CAAC;AAErD,uDAAuD;AACvD,MAAM,MAAM,sBAAsB,GAC/B,qBAAqB,GACrB,mBAAmB,GACnB,0BAA0B,GAC1B,2BAA2B,GAC3B,wBAAwB,GACxB,yBAAyB,CAAC;AAE7B,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACrC,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,mDAAmD;IACnD,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,qBAAqB,EA2CpE,CAAC;AAEF,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,qBAAqB,EAC9B,KAAK,EAAE,UAAU,GAAG,SAAS,GAC3B,MAAM,CAGR;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,UAAU,CAAC,CAQrB"}

package/dist/pptx/render/connector-authoring.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `connector-authoring`: turning a drag between two connection sites into a
+ * bound `p:cxnSp`.
+ *
+ * The counterpart to `connector-reroute`. That module keeps an existing
+ * connector attached while its shapes move; this one decides what a NEW
+ * connector looks like when the user drags from a site on one shape to a site
+ * on another: which endpoints it spans, which preset carries it, and the
+ * `a:stCxn` / `a:endCxn` bindings that make the reroute possible at all.
+ *
+ * It exists as a shared decision function because the snapping used to live
+ * inside a React hook, and it disagreed with the reroute it fed: authoring
+ * snapped to `getConnectionSites` (the four edge midpoints, the FALLBACK for a
+ * shape whose real sites are unknown) while the reroute resolved the same index
+ * through `getShapeConnectionSites` (the shape's parsed `a:cxnLst`). On any
+ * non-rectangular shape the connector was therefore drawn to one point and then
+ * jumped to a different one the first time the shape moved. Both paths now read
+ * the same site list.
+ *
+ * @module render/connector-authoring
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** A resolved endpoint: which shape, which of its connection sites. */
+export interface ConnectorEndpointRef {
+    element: PptxElement;
+    siteIndex: number;
+}
+/** The geometry and bindings a new connector needs, in slide pixels. */
+export interface AuthoredConnector {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Preset chosen from the span; see {@link connectorPresetForSpan}. */
+    shapeType: string;
+    startConnection: {
+        shapeId: string;
+        connectionSiteIndex: number;
+    };
+    endConnection: {
+        shapeId: string;
+        connectionSiteIndex: number;
+    };
+}
+/**
+ * The preset a connector of this span should use.
+ *
+ * A short hop reads best as a straight rule, a medium one as an elbow, and a
+ * long one as a curve, which is roughly what PowerPoint's own connector tool
+ * produces when you drag between two shapes.
+ */
+export declare function connectorPresetForSpan(span: number): string;
+/**
+ * The id a connector endpoint should reference this element by.
+ *
+ * Prefers the OOXML `p:cNvPr/@id` the parser kept on `shapeId`, because that is
+ * what `a:stCxn/@id` must contain for the saved package to be valid; falls back
+ * to the model id for an element minted in the session, which has no cNvPr id
+ * until save time. `connector-reroute` resolves both spellings.
+ */
+export declare function connectorEndpointId(element: PptxElement): string;
+/**
+ * The absolute slide-pixel point of one endpoint.
+ *
+ * Resolved through `getShapeConnectionSites`, so a site index means the same
+ * thing here as it does to the reroute.
+ */
+export declare function connectorEndpointPoint(endpoint: ConnectorEndpointRef): {
+    x: number;
+    y: number;
+};
+/**
+ * Describe the connector a drag from `start` to `end` should create, or `null`
+ * when the drag does not describe one (no target, or both ends on one shape:
+ * PowerPoint will not bind a connector to a single shape twice).
+ */
+export declare function authorConnectorBetweenSites(start: ConnectorEndpointRef, end: ConnectorEndpointRef): AuthoredConnector | null;
+//# sourceMappingURL=connector-authoring.d.ts.map

package/dist/pptx/render/connector-authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-authoring.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,uEAAuE;AACvE,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,WAAW,iBAAiB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,aAAa,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;CAChE;AAOD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,oBAAoB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAI/F;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,oBAAoB,EAC3B,GAAG,EAAE,oBAAoB,GACvB,iBAAiB,GAAG,IAAI,CA2B1B"}

package/dist/pptx/render/connector-dash.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Dash patterns for connector lines.
+ *
+ * Split out of `connector-path.ts` alongside the arrow markers: a connector's
+ * stroke decoration is a separate concern from where the line is routed, and
+ * both are configured independently in the inspector.
+ *
+ * Pure and framework-agnostic.
+ */
+/** A single custom-dash segment (percent-of-line-width, 1000ths of a percent). */
+export interface DashSegment {
+    dash: number;
+    space: number;
+}
+/**
+ * Return the SVG `stroke-dasharray` string for a given OOXML stroke dash preset
+ * and width, or `undefined` for solid lines (no attribute needed).
+ *
+ * Produces a distinct pattern per preset (`dash`, `lgDash`, `dashDot`,
+ * `sysDashDotDot`, etc.) rather than collapsing every non-dot preset to a single
+ * `3w/w` approximation, and honours a `custDash` segment list (`a:custDash/a:ds`)
+ * when supplied. This delegates to the same {@link getSvgStrokeDasharray} the
+ * shape/border code uses, so connectors and shape outlines stay in lock-step.
+ *
+ * @param dash               Raw `a:ln/@prstDash` token (e.g. `"lgDashDot"`).
+ * @param strokeWidth        Resolved stroke width in px.
+ * @param customDashSegments Optional `custDash` segments; when present they take
+ *                           precedence and are rendered as an explicit pattern.
+ */
+export declare function buildDashArray(dash: string | undefined, strokeWidth: number, customDashSegments?: ReadonlyArray<DashSegment>): string | undefined;
+//# sourceMappingURL=connector-dash.d.ts.map

package/dist/pptx/render/connector-dash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-dash.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-dash.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,CAAC,EAAE,aAAa,CAAC,WAAW,CAAC,GAC7C,MAAM,GAAG,SAAS,CASpB"}