ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/selection-control-artwork.d.ts

@@ -0,0 +1,61 @@
+/** Opt-in artwork tokens. Defaults belong to each binding, not the theme root. */
+export declare const SELECTION_CONTROL_CSS_VARS: {
+    readonly cornerSize: '--pptx-selection-corner-size';
+    readonly cornerRadius: '--pptx-selection-corner-radius';
+    readonly edgeLength: '--pptx-selection-edge-length';
+    readonly edgeThickness: '--pptx-selection-edge-thickness';
+    readonly edgeRadius: '--pptx-selection-edge-radius';
+    readonly handleFill: '--pptx-selection-handle-fill';
+    readonly handleBorderColor: '--pptx-selection-handle-border-color';
+    readonly outlineColor: '--pptx-selection-outline-color';
+    readonly rotateSize: '--pptx-selection-rotate-size';
+    readonly rotateFill: '--pptx-selection-rotate-fill';
+    readonly rotateForeground: '--pptx-selection-rotate-foreground';
+};
+export type SelectionControlArtworkKind = 'corner' | 'horizontal-edge' | 'vertical-edge' | 'rotate';
+/** Existing binding values, including responsive CSS fallbacks when needed. */
+export interface SelectionControlArtworkDefaults {
+    /** Positive screen-pixel lengths. Numbers mean px; strings may use local var(). */
+    width: number | string;
+    height: number | string;
+    /** Local CSS radius, like the binding's existing border and shadow styling. */
+    radius: string;
+    fill: string;
+    borderColor: string;
+    foreground?: string;
+}
+/**
+ * Style a centered, aria-hidden artwork child, not the interactive hit region.
+ * Callers retain their existing border width, shadow, anchors, hit padding and
+ * neighbor partition. Frame dimensions never shrink below the binding default;
+ * larger artwork grows the frame, while the existing partition still owns hits.
+ * Center that frame on its anchor; fixed offsets for half the OLD width/height
+ * would shift a growing control. Radius/borders/shadows keep local CSS units.
+ *
+ * inverseScale converts screen lengths to the binding's coordinate space. Use
+ * 1 for an unscaled overlay or a button already inverse-scaled as a whole.
+ * Defaults are trusted binding constants. var() falls back only for omitted
+ * tokens; the helper does not read or sanitize arbitrary inherited CSS values.
+ */
+export declare function getSelectionControlArtworkStyle(kind: SelectionControlArtworkKind, defaults: SelectionControlArtworkDefaults, inverseScale?: number): {
+    frame: {
+        width: string;
+        height: string;
+    };
+    artwork: {
+        position: 'absolute';
+        left: string;
+        top: string;
+        transform: string;
+        pointerEvents: 'none';
+        width: string;
+        height: string;
+        borderRadius: string;
+        background: string;
+        borderColor: string;
+        color?: string | undefined;
+    };
+};
+/** Shared by the selection outline and the binding's existing Rotate stem. */
+export declare function getSelectionOutlineColor(fallback: string): string;
+//# sourceMappingURL=selection-control-artwork.d.ts.map

package/dist/pptx/render/selection-control-artwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-control-artwork.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-control-artwork.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,eAAO,MAAM,0BAA0B;aACtC,UAAU,EAAE,8BAA8B;aAC1C,YAAY,EAAE,gCAAgC;aAC9C,UAAU,EAAE,8BAA8B;aAC1C,aAAa,EAAE,iCAAiC;aAChD,UAAU,EAAE,8BAA8B;aAC1C,UAAU,EAAE,8BAA8B;aAC1C,iBAAiB,EAAE,sCAAsC;aACzD,YAAY,EAAE,gCAAgC;aAC9C,UAAU,EAAE,8BAA8B;aAC1C,UAAU,EAAE,8BAA8B;aAC1C,gBAAgB,EAAE,oCAAoC;CAC7C,CAAC;AAEX,MAAM,MAAM,2BAA2B,GAAG,QAAQ,GAAG,iBAAiB,GAAG,eAAe,GAAG,QAAQ,CAAC;AAEpG,+EAA+E;AAC/E,MAAM,WAAW,+BAA+B;IAC/C,mFAAmF;IACnF,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC9C,IAAI,EAAE,2BAA2B,EACjC,QAAQ,EAAE,+BAA+B,EACzC,YAAY,SAAI;;QAuBd,KAAK;QACL,MAAM;;;kBAGI,UAAU;;;;uBAIL,MAAM;;;;;;;;EAiBvB;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/dist/pptx/render/selection-cycle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tab / Shift+Tab selection cycling: PowerPoint moves the current selection to
+ * the next (or previous) object on the slide, in tab order, wrapping at both
+ * ends. This is the one pure decision the five bindings would otherwise each
+ * reimplement over their own element-id array, so it lives here once.
+ *
+ * @module render/selection-cycle
+ */
+/** A Tab press's direction through the slide's elements. */
+export type SelectionCycleDirection = 'next' | 'prev';
+/**
+ * Resolve the element a Tab (or Shift+Tab) press should select next.
+ *
+ * `ids` is the slide's elements in tab order (typically z-order, matching
+ * `slide.elements`). With nothing currently selected, `next` lands on the
+ * first element and `prev` on the last, mirroring PowerPoint. With a
+ * selection that is no longer in `ids` (the element was deleted, or belongs
+ * to another slide), the cycle restarts the same way. Returns `null` only
+ * when the slide has no elements to select.
+ */
+export declare function cycleSelectableElement(ids: readonly string[], currentId: string | null, direction: SelectionCycleDirection): string | null;
+//# sourceMappingURL=selection-cycle.d.ts.map

package/dist/pptx/render/selection-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-cycle.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,4DAA4D;AAC5D,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACrC,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,SAAS,EAAE,uBAAuB,GAChC,MAAM,GAAG,IAAI,CAWf"}

package/dist/pptx/render/selection-format-state.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pressed state and toggle decision for the ribbon's Bold / Italic /
+ * Underline / Strikethrough buttons.
+ *
+ * Every binding used to decide the next value as `!element.textStyle.bold`:
+ * the body-level style, which knows nothing about the runs. A word that is
+ * bold at run level inside a non-bold body read as "off", so clicking Bold
+ * re-applied bold and the word could never be un-bolded from the ribbon.
+ *
+ * The state is derived from the runs the user selected (all content runs when
+ * nothing is selected; the body style when there are no runs at all), as a
+ * tri-state so a mixed selection is honest: PowerPoint turns a mixed or off
+ * selection ON, and only an all-on selection OFF.
+ */
+import type { PptxElement, TextSegment, TextStyle } from 'ooxml-core/pptx';
+import type { InlineTextSelection } from './inline-selection-utils.js';
+/** The pressed state of one toggle over the selected runs. */
+export type TextStyleFlagState = 'on' | 'off' | 'mixed';
+/** The boolean run decorations the ribbon toggles. */
+export type TextDecorationFlag = 'bold' | 'italic' | 'underline' | 'strikethrough';
+export declare const TEXT_DECORATION_FLAGS: readonly TextDecorationFlag[];
+/** Per-toggle tri-state, one entry per {@link TextDecorationFlag}. */
+export type SelectionTextStyleFlags = Record<TextDecorationFlag, TextStyleFlagState>;
+/** A run that carries text: not a paragraph break, not a display-only bullet marker. */
+export declare function isContentSegment(segment: TextSegment): boolean;
+/**
+ * The content runs a toggle acts on: those inside the selection's segment
+ * range, or every content run when there is no selection.
+ */
+export declare function contentSegmentsInSelection(segments: readonly TextSegment[] | undefined, selection: InlineTextSelection | null): TextSegment[];
+/**
+ * The tri-state of each decoration over the selected runs. A run without an
+ * explicit value inherits the body's, exactly as the renderer paints it. With
+ * no content runs at all the body style decides.
+ */
+export declare function getSelectionTextStyleFlags(segments: readonly TextSegment[] | undefined, selection: InlineTextSelection | null, elementTextStyle: Partial<TextStyle> | undefined): SelectionTextStyleFlags;
+/** What a click should write: only an all-on selection turns off. */
+export declare function nextToggleValue(state: TextStyleFlagState): boolean;
+/**
+ * {@link getSelectionTextStyleFlags} for an element: its runs (or `segments`,
+ * a fresher copy from a live inline edit) against its body style. All off for
+ * an element without text properties.
+ */
+export declare function textStyleFlagsOf(element: PptxElement | null | undefined, selection?: InlineTextSelection | null, segments?: readonly TextSegment[]): SelectionTextStyleFlags;
+//# sourceMappingURL=selection-format-state.d.ts.map

package/dist/pptx/render/selection-format-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-format-state.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-format-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,KAAK,GAAG,OAAO,CAAC;AAExD,sDAAsD;AACtD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,eAAe,CAAC;AAEnF,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAK9D,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAC;AAErF,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAO9D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,EAC5C,SAAS,EAAE,mBAAmB,GAAG,IAAI,GACnC,WAAW,EAAE,CAwBf;AASD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,EAC5C,SAAS,EAAE,mBAAmB,GAAG,IAAI,EACrC,gBAAgB,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,GAC9C,uBAAuB,CAWzB;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAElE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACvC,SAAS,GAAE,mBAAmB,GAAG,IAAW,EAC5C,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,GAC/B,uBAAuB,CAKzB"}

package/dist/pptx/render/selection-handle-visibility.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether an element's resize/rotate/adjustment handles should be shown.
+ *
+ * Handles stay visible and draggable while the SAME element is actively
+ * inline-edited (PowerPoint keeps a text box's handles live mid-edit; you can
+ * grab a corner without first clicking out of edit mode). Every handle's own
+ * hit target is a small button at the box's edge/corner with `stopPropagation`
+ * on its own pointer-down, and the handle host itself is `pointer-events:
+ * none` everywhere else, so leaving handles mounted during inline edit does
+ * not capture clicks meant for caret placement in the interior of the text.
+ * There is nothing to gate on an inline-edit flag here: only whether the
+ * canvas is editable, the element is the (single) selection, and - for the
+ * unclipped overlay variant - it isn't a connector/line, which renders its
+ * own handles inside its own (already unclipped) element instead.
+ */
+export declare function shouldShowElementHandles(isEditableCanvas: boolean, isSelected: boolean, selectedCount: number): boolean;
+//# sourceMappingURL=selection-handle-visibility.d.ts.map

package/dist/pptx/render/selection-handle-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-handle-visibility.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-handle-visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACvC,gBAAgB,EAAE,OAAO,EACzB,UAAU,EAAE,OAAO,EACnB,aAAa,EAAE,MAAM,GACnB,OAAO,CAET"}

package/dist/pptx/render/selection-pane-rename.d.ts

@@ -0,0 +1,44 @@
+/**
+ * What a Selection Pane rename commit means.
+ *
+ * All five bindings run the same little decision when a rename input is
+ * committed (Enter, or blur), and all five had drifted into the same wrong
+ * answer for one of its three cases. It lives here as a pure decision function
+ * so the next correction lands once.
+ */
+/** The patch to merge onto the element, or `null` for "commit nothing". */
+export interface SelectionPaneRenameCommit {
+    /**
+     * The new `element.name`. Never `undefined`: the save writer
+     * (`applyNameToCnvPr`) reads `undefined` as "the model has no opinion, leave
+     * the markup alone", so committing it cannot express a clear.
+     */
+    name: string;
+}
+/**
+ * Decide what to commit for a Selection Pane rename.
+ *
+ * Three cases, and the middle one is the fix:
+ *
+ * 1. **Unedited** (the trimmed value equals the trimmed seed the input was
+ *    opened with): `null`. Nothing is written, so a fallback display label
+ *    ("Shape 3", or the element id) is never persisted as a real name just
+ *    because the user double-clicked a row and clicked away.
+ * 2. **Emptied**: `{ name: '' }`. Clearing the box has to mean something, and
+ *    an explicit empty string is the ONLY value that means it. `@name` is
+ *    REQUIRED on `CT_NonVisualDrawingProps` (ECMA-376 S20.1.2.2.8), so the
+ *    attribute can never be deleted; the writer emits `name=""`. All five
+ *    bindings used to commit `undefined` here, which the writer reads as "no
+ *    opinion" (charts, SmartArt and other graphic frames parse without a
+ *    `name` while their markup carries a real one, so blanking on `undefined`
+ *    would wipe those on a plain round-trip). The result was that clearing a
+ *    name in the pane did nothing at all: it did not reach the file, and on
+ *    reload the old name came straight back.
+ * 3. **Renamed**: `{ name: trimmed }`.
+ *
+ * @param seed  - The value the input was seeded with when editing began.
+ * @param value - The current input value.
+ * @returns The patch to apply, or `null` when the commit is a no-op.
+ */
+export declare function resolveSelectionPaneRename(seed: string, value: string): SelectionPaneRenameCommit | null;
+//# sourceMappingURL=selection-pane-rename.d.ts.map

package/dist/pptx/render/selection-pane-rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-pane-rename.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-pane-rename.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACX,yBAAyB,GAAG,IAAI,CAMlC"}

package/dist/pptx/render/selection-transform.d.ts

@@ -0,0 +1,15 @@
+import type { InteractionBox } from './element-interaction.js';
+/** Element geometry used by collective selection transforms. */
+export interface SelectionTransformBox extends InteractionBox {
+    id: string;
+}
+/** Union of all selected element boxes, or null for an empty selection. */
+export declare function selectionBounds(boxes: readonly SelectionTransformBox[]): InteractionBox | null;
+/** Move all boxes by the same slide-space delta. */
+export declare function moveSelection(boxes: readonly SelectionTransformBox[], dx: number, dy: number): SelectionTransformBox[];
+/**
+ * Scale boxes from one selection boundary into another. Each element keeps its
+ * relative position and size within the collective selection.
+ */
+export declare function resizeSelection(boxes: readonly SelectionTransformBox[], from: InteractionBox, to: InteractionBox): SelectionTransformBox[];
+//# sourceMappingURL=selection-transform.d.ts.map

package/dist/pptx/render/selection-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-transform.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/selection-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,gEAAgE;AAChE,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC5D,EAAE,EAAE,MAAM,CAAC;CACX;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,GAAG,cAAc,GAAG,IAAI,CAS9F;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAC5B,KAAK,EAAE,SAAS,qBAAqB,EAAE,EACvC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACR,qBAAqB,EAAE,CAEzB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,SAAS,qBAAqB,EAAE,EACvC,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,cAAc,GAChB,qBAAqB,EAAE,CAUzB"}

package/dist/pptx/render/session-restore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * session-restore: keep the deck a host app has open across a page refresh.
+ *
+ * A host (the demo apps, or any embedder) owns the bytes it hands to the
+ * viewer, so a plain reload drops them and the user lands back on the file
+ * dropzone with their presentation gone. This store remembers the open deck in
+ * IndexedDB and hands it back on the next load.
+ *
+ * Scope is deliberately per-tab: the record is keyed by an id kept in
+ * `sessionStorage`, which survives a reload but NOT a new tab. Refreshing
+ * restores the deck this tab had open, while a second tab opened on the same
+ * origin still starts on the landing page, and two tabs holding different decks
+ * never steal each other's content.
+ *
+ * `restoreSessionDeck` additionally prefers a NEWER autosave snapshot for the
+ * same file (see `./autosave-store`), so a refresh mid-edit comes back with the
+ * edited deck rather than the pristine bytes that were first opened.
+ *
+ * Every operation is best-effort: a blocked IndexedDB, a partitioned
+ * `sessionStorage`, or an exhausted quota degrades to "no restore", never to a
+ * thrown error in the host.
+ */
+/** A deck remembered for the current tab. */
+export interface SessionDeck {
+    /** File name the deck was opened under, used as the autosave key. */
+    fileName: string;
+    /** The presentation bytes. */
+    data: Uint8Array;
+    /** When these bytes were remembered (epoch ms). */
+    timestamp: number;
+}
+/**
+ * This tab's session id, or `null` when `sessionStorage` is unavailable (a
+ * sandboxed iframe, or a browser with storage disabled).
+ *
+ * @param create Mint and persist an id when the tab does not have one yet.
+ *   Reads pass `false` so a fresh tab never claims another tab's record.
+ */
+export declare function getSessionTabId(create?: boolean): string | null;
+/**
+ * Remember `data` as the deck this tab has open, so the next load can restore
+ * it. Resolves `false` when the browser refused to store it; callers treat that
+ * as "no restore available later", never as an error.
+ */
+export declare function rememberSessionDeck(fileName: string, data: Uint8Array): Promise<boolean>;
+/** The deck remembered for this tab, or `null` when there is nothing to restore. */
+export declare function loadSessionDeck(): Promise<SessionDeck | null>;
+/** Forget this tab's deck (the host closed it, or handed the tab to another flow). */
+export declare function forgetSessionDeck(): Promise<void>;
+/**
+ * The deck to reopen on load: this tab's remembered bytes, upgraded to a newer
+ * autosave snapshot of the same file when the viewer wrote one after they were
+ * remembered. Without that upgrade a refresh mid-edit would silently roll the
+ * presentation back to the state it was opened in.
+ */
+export declare function restoreSessionDeck(): Promise<SessionDeck | null>;
+//# sourceMappingURL=session-restore.d.ts.map

package/dist/pptx/render/session-restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-restore.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/session-restore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAiBH,6CAA6C;AAC7C,MAAM,WAAW,WAAW;IAC3B,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;CAClB;AAcD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,UAAQ,GAAG,MAAM,GAAG,IAAI,CAkB7D;AAoED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CA2B9F;AAED,oFAAoF;AACpF,wBAAsB,eAAe,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmCnE;AAED,sFAAsF;AACtF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBvD;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAgBtE"}

package/dist/pptx/render/shape-adjustment-custom-geometry.d.ts

@@ -0,0 +1,13 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { DerivedAdjustmentHandle } from './shape-adjustment-model.js';
+/**
+ * Every adjust handle a `a:custGeom` shape's own `a:ahLst` declares, derived
+ * by evaluating each `a:ahXY`/`a:ahPolar` against the geometry's `a:avLst`/
+ * `a:gdLst` (overridden by any in-progress `shapeAdjustments` patch, so a
+ * drag repositions the handle live) and probing its drag scale.
+ *
+ * Empty for a shape with no `a:ahLst`, or one whose `customGeometryRawData`
+ * did not survive parse (nothing to evaluate `a:gdLst` against).
+ */
+export declare function deriveCustomGeometryAdjustmentHandles(element: PptxElement): DerivedAdjustmentHandle[];
+//# sourceMappingURL=shape-adjustment-custom-geometry.d.ts.map

package/dist/pptx/render/shape-adjustment-custom-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment-custom-geometry.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment-custom-geometry.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAIX,WAAW,EACX,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAEX,uBAAuB,EAEvB,MAAM,0BAA0B,CAAC;AA2MlC;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,CACpD,OAAO,EAAE,WAAW,GAClB,uBAAuB,EAAE,CAqC3B"}

package/dist/pptx/render/shape-adjustment-handles.d.ts

@@ -0,0 +1,10 @@
+import type { DerivedAdjustmentHandle } from './shape-adjustment-model.js';
+/**
+ * The adjust handles for a preset at the given box and adjustment values, in
+ * `avLst` declaration order (`adj`/`adj1` first, as PowerPoint lists them).
+ *
+ * Returns an empty array for a preset with no adjustable parameter, and skips
+ * any single key whose value moves no vertex at all.
+ */
+export declare function derivePresetAdjustmentHandles(presetName: string | undefined, width: number, height: number, adjustments?: Record<string, number>): DerivedAdjustmentHandle[];
+//# sourceMappingURL=shape-adjustment-handles.d.ts.map

package/dist/pptx/render/shape-adjustment-handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment-handles.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment-handles.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAkExE;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC5C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACtC,uBAAuB,EAAE,CA8B3B"}

package/dist/pptx/render/shape-adjustment-model.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `shape-adjustment-model`: the vocabulary the adjust-handle modules share.
+ *
+ * The `a:ahLst` work is split three ways for the repo's file-size budget:
+ * `shape-adjustment-probe` measures the geometry, `shape-adjustment-handles`
+ * derives the handles from those measurements, and `shape-adjustment-solver`
+ * turns a pointer position back into guide values. All three need these types
+ * and the one rule that operates purely on them, so they live here and the
+ * dependency graph stays a DAG rather than a cycle.
+ *
+ * @module render/shape-adjustment-model
+ */
+/**
+ * How a pointer position becomes a guide value, captured once when the gesture
+ * starts so `pointermove` stays pure arithmetic.
+ */
+export interface ShapeAdjustmentSolver {
+    /** `linear`: the handle slides. `angular`: it swings about {@link centerX}. */
+    kind: 'linear' | 'angular';
+    /** Handle position in element-local px at {@link startValue}. */
+    anchorX: number;
+    anchorY: number;
+    /** Element-local px the handle travels per ONE unit of guide value. */
+    dirX: number;
+    dirY: number;
+    /** Pivot for an angular handle (the shape centre). */
+    centerX: number;
+    centerY: number;
+    /** The guide value the anchor was measured at. */
+    startValue: number;
+    /** Guide-space bounds, taken from the preset's own `pin` clamp. */
+    min: number;
+    max: number;
+}
+/** One guide a handle drives. */
+export interface AdjustmentAxisSolver {
+    key: string;
+    solver: ShapeAdjustmentSolver;
+}
+/**
+ * One derived handle: where it sits and which guides its drag writes.
+ *
+ * A handle usually drives ONE guide, but the callout family binds two to a
+ * single diamond (`<ahXY gdRefX="adj2" gdRefY="adj1">`), so `solvers` is a
+ * list: one drag writes the leader line's x AND y offsets, as PowerPoint does.
+ */
+export interface DerivedAdjustmentHandle {
+    /** The primary `a:avLst` guide name (`adj`, `adj1`, ...). */
+    key: string;
+    /** Element-local px, origin = element top-left. */
+    x: number;
+    y: number;
+    /** The primary guide's current value. */
+    value: number;
+    cursor: string;
+    solvers: AdjustmentAxisSolver[];
+}
+/**
+ * Fold two single-axis handles that landed on the SAME vertex into one
+ * two-guide handle.
+ *
+ * The callout family declares exactly that shape (`<ahXY gdRefX="adj2"
+ * gdRefY="adj1">`): one diamond on the leader-line elbow that writes an x
+ * offset and a y offset. Derived independently, `adj1` and `adj2` come back as
+ * two handles sitting on top of each other, only one of which the user could
+ * ever grab. Only two LINEAR guides on roughly perpendicular axes are folded;
+ * an angular guide keeps its own handle, because sweeping an arc and thickening
+ * it are separate gestures in PowerPoint.
+ */
+export declare function mergeCoincidentHandles(handles: DerivedAdjustmentHandle[]): DerivedAdjustmentHandle[];
+//# sourceMappingURL=shape-adjustment-model.d.ts.map

package/dist/pptx/render/shape-adjustment-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment-model.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,+EAA+E;IAC/E,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,iCAAiC;AACjC,MAAM,WAAW,oBAAoB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,qBAAqB,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACvC,6DAA6D;IAC7D,GAAG,EAAE,MAAM,CAAC;IACZ,mDAAmD;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,oBAAoB,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,uBAAuB,EAAE,GAChC,uBAAuB,EAAE,CA4C3B"}

package/dist/pptx/render/shape-adjustment-probe.d.ts

@@ -0,0 +1,58 @@
+import type { PresetShapeGeometryDefinition } from 'ooxml-core/pptx';
+/** OOXML angle unit: 60000ths of a degree. A full turn is 21,600,000. */
+export declare const ANGLE_UNITS_PER_TURN = 21600000;
+export declare const ANGLE_UNITS_PER_RADIAN: number;
+/**
+ * The `adj` keys that reach an ANGLE operand, transitively.
+ *
+ * `pie`, `arc`, `chord`, `blockArc` and the circular arrows adjust an angle in
+ * 60000ths of a degree, so a linear projection of the pointer would be wrong
+ * over anything but a tiny drag. Which keys those are is read off the data
+ * rather than listed: a key is angular when it reaches an `arcTo` start/sweep
+ * angle, or the angle operand (argument 1) of `cos` / `sin` / `tan`.
+ * `blockArc`'s `adj3` also reaches `cos`, but as argument 0 (a radius), so it
+ * correctly stays cartesian.
+ */
+export declare function angularAdjustmentKeys(def: PresetShapeGeometryDefinition): Set<string>;
+/**
+ * The `[min, max]` an adjustment is clamped to, read off the preset's own
+ * `pin <lo> <key> <hi>` guide - the same pair `<ahXY minX maxX>` repeats.
+ * `chevron`'s upper bound is the guide `maxAdj`, so the bound is resolved
+ * against the evaluated variable map rather than assumed numeric.
+ */
+export declare function adjustmentRange(def: PresetShapeGeometryDefinition, key: string, vars: Map<string, number>, isAngular: boolean): {
+    min: number;
+    max: number;
+};
+/**
+ * Every coordinate pair in an evaluated preset's path data, in order.
+ *
+ * The `d` strings come from this repo's own emitter, so the grammar is known
+ * and {@link COMMAND_ARITY} is enough to walk it. The number alternative is
+ * FIRST in the tokeniser so an exponent-form coordinate (`1e-7`) is consumed
+ * whole rather than split at its `e` and mistaken for a command letter.
+ */
+export declare function pathCoordinates(paths: ReadonlyArray<{
+    d: string;
+}>): number[];
+/** Evaluated path coordinates for `preset` at a given adjustment map. */
+export declare function coordinatesAt(preset: string, width: number, height: number, adjustments: Record<string, number>): number[] | null;
+/** One vertex's movement between two evaluations of the same preset. */
+export interface VertexDisplacement {
+    index: number;
+    dx: number;
+    dy: number;
+}
+/**
+ * The vertex that moves most between two evaluations, and by how much.
+ *
+ * An adjustment usually moves several vertices by exactly the same amount (a
+ * `roundRect`'s corner radius moves all eight arc ends; `plus` moves all
+ * twelve). PowerPoint always puts the handle on the topmost, then leftmost, of
+ * those, so ties are broken that way rather than by path order: `roundRect`'s
+ * path begins at `(l, x1)`, and taking that would have given a handle that
+ * slides DOWN the left edge instead of along the top edge as
+ * `<ahXY gdRefX="adj"><pos x="x1" y="t"/></ahXY>` specifies.
+ */
+export declare function dominantDisplacement(base: number[], probe: number[]): VertexDisplacement | null;
+//# sourceMappingURL=shape-adjustment-probe.d.ts.map

package/dist/pptx/render/shape-adjustment-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment-probe.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment-probe.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAErE,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,sBAAsB,QAAuC,CAAC;AAU3E;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,6BAA6B,GAAG,GAAG,CAAC,MAAM,CAAC,CAuCrF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,6BAA6B,EAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzB,SAAS,EAAE,OAAO,GAChB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAwB9B;AAYD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,CAAC;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,CAyB7E;AAED,yEAAyE;AACzE,wBAAgB,aAAa,CAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,MAAM,EAAE,GAAG,IAAI,CAGjB;AAED,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,kBAAkB,GAAG,IAAI,CAwB/F"}

package/dist/pptx/render/shape-adjustment-solver.d.ts

@@ -0,0 +1,16 @@
+import type { AdjustmentAxisSolver, ShapeAdjustmentSolver } from './shape-adjustment-model.js';
+/**
+ * The guide value for a pointer at `(localX, localY)` in element-local px.
+ *
+ * Linear handles project the pointer onto the measured travel direction, which
+ * for `roundRect` reduces exactly to the old `deltaX / (ss/100000)` formula.
+ * Angular handles take the swept angle about the shape centre, so dragging the
+ * end of a `pie` wedge halfway round the circle moves it halfway round.
+ */
+export declare function solveShapeAdjustmentValue(solver: ShapeAdjustmentSolver, localX: number, localY: number): number;
+/**
+ * The `shapeAdjustments` patch a pointer at `(localX, localY)` implies for a
+ * handle: one entry per guide the handle drives.
+ */
+export declare function solveShapeAdjustments(solvers: readonly AdjustmentAxisSolver[], localX: number, localY: number): Record<string, number>;
+//# sourceMappingURL=shape-adjustment-solver.d.ts.map

package/dist/pptx/render/shape-adjustment-solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment-solver.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment-solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAuB5F;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACZ,MAAM,CA+BR;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,SAAS,oBAAoB,EAAE,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}

package/dist/pptx/render/shape-adjustment.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Shape-adjustment handles: PowerPoint's yellow `a:avLst` diamonds. Pure,
+ * framework-agnostic math shared by all five bindings.
+ *
+ * Owns the adjustment scalar constants and the handle/drag descriptor types so
+ * each binding consumes one copy rather than re-declaring them.
+ *
+ * A preset has ONE handle per adjustable parameter and many presets have
+ * several (`callout3` has eight), so the entry point is
+ * {@link getShapeAdjustmentHandleDescriptors}, returning an array. Placement and
+ * drag scale are measured off the preset geometry by
+ * `shape-adjustment-handles`; this module is the element-level policy around
+ * it (lock check, element type, custom geometry) plus the round-rect helpers
+ * the renderers use for `border-radius`.
+ */
+import type { PptxElement, PptxElementWithShapeStyle } from 'ooxml-core/pptx';
+import type { AdjustmentAxisSolver } from './shape-adjustment-model.js';
+export declare const SHAPE_ADJUSTMENT_MIN = 0;
+export declare const SHAPE_ADJUSTMENT_MAX = 50000;
+export declare const DEFAULT_ROUND_RECT_ADJUSTMENT = 16667;
+/** Descriptor for one draggable adjustment handle (the amber diamond). */
+export interface ShapeAdjustmentHandleDescriptor {
+    /** The `a:avLst` guide name this handle writes (`adj`, `adj1`, ...). */
+    key: string;
+    /** Handle x offset in element-local px (origin = element top-left). */
+    left: number;
+    /** Handle y offset in element-local px. */
+    top: number;
+    /**
+     * Current adjustment value in GUIDE units, not a 0-1 fraction. Most presets
+     * range 0..50000 or 0..100000 and the angular ones run to 21,600,000.
+     */
+    value: number;
+    cursor: string;
+    /**
+     * How this handle's drag resolves, measured off the preset geometry: one
+     * entry per `a:avLst` guide it drives (callouts drive two). Absent only for
+     * a caller that built a descriptor by hand.
+     */
+    solvers?: AdjustmentAxisSolver[];
+}
+/** Live drag state captured when an adjustment gesture starts. */
+export interface ShapeAdjustmentDragState {
+    elementId: string;
+    key: string;
+    shapeType: string;
+    startClientX: number;
+    startClientY: number;
+    startAdjustment: number;
+    startWidth: number;
+    startHeight: number;
+    moved: boolean;
+    /** Copied from the descriptor the gesture started on. */
+    solvers?: AdjustmentAxisSolver[];
+    /**
+     * The element's whole `a:avLst` map at gesture start.
+     *
+     * A binding writes `shapeAdjustments` as one object, so a drag that sent
+     * only the guide it changed would DELETE every other authored adjustment on
+     * a multi-adjust preset (a `quadArrow` would lose two of its three the first
+     * time one was touched).
+     */
+    startAdjustments?: Record<string, number>;
+}
+export declare function clampShapeAdjustmentValue(value: number): number;
+export declare function getRoundRectAdjustmentValue(element: PptxElementWithShapeStyle): number;
+export declare function getRoundRectRadiusPx(element: PptxElementWithShapeStyle): number;
+/**
+ * Every adjustment handle `element` offers, in `a:avLst`/`a:ahLst`
+ * declaration order.
+ *
+ * A `a:custGeom` shape with its own `a:ahXY`/`a:ahPolar` gets its handles from
+ * {@link deriveCustomGeometryAdjustmentHandles} (evaluated off its OWN
+ * `a:gdLst`, not the preset table, which would describe geometry nobody
+ * paints for a freeform shape); a preset shape gets them from
+ * `derivePresetAdjustmentHandles`. Empty when neither applies, or when the
+ * element's `a:spLocks/@noAdjustHandles` forbids the affordance. The lock
+ * check lives HERE rather than at each binding's overlay, so a locked shape
+ * hides its amber diamonds in all five without five separate guards.
+ */
+export declare function getShapeAdjustmentHandleDescriptors(element: PptxElement): ShapeAdjustmentHandleDescriptor[];
+/**
+ * The FIRST adjustment handle for `element`, or `null`.
+ *
+ * Kept for callers that only ever showed one diamond; new view code should
+ * render {@link getShapeAdjustmentHandleDescriptors} so a preset with several
+ * adjustable parameters offers all of them.
+ */
+export declare function getShapeAdjustmentHandleDescriptor(element: PptxElement): ShapeAdjustmentHandleDescriptor | null;
+/**
+ * New adjustment value for a pointer delta (element px) from the gesture start.
+ *
+ * `deltaY` matters for every handle that does not travel horizontally (the
+ * vertical arm of a `quadArrow`, a callout's leader line, the swing of a `pie`
+ * wedge); it defaults to 0 so a caller that only tracks horizontal travel keeps
+ * working.
+ */
+export declare function getDraggedShapeAdjustmentValue(state: ShapeAdjustmentDragState, deltaX: number, deltaY?: number): number;
+/**
+ * The whole `shapeAdjustments` map to write for a drag delta (element px).
+ *
+ * This is what a binding should write, not a single value: a callout handle
+ * drives two guides at once (so resolving only
+ * {@link getDraggedShapeAdjustmentValue} would move its leader line
+ * horizontally and never vertically), and the result carries the element's
+ * other adjustments forward so writing it cannot drop them.
+ */
+export declare function getDraggedShapeAdjustments(state: ShapeAdjustmentDragState, deltaX: number, deltaY?: number): Record<string, number>;
+/**
+ * Capture the drag state for an adjustment gesture starting on `descriptor`.
+ *
+ * Shared so no binding has to remember to copy the solver across (and so none
+ * repeats the `shapeType` lower-casing that used to be needed).
+ */
+export declare function beginShapeAdjustment(element: PptxElement, descriptor: ShapeAdjustmentHandleDescriptor, clientX: number, clientY: number): ShapeAdjustmentDragState;
+//# sourceMappingURL=shape-adjustment.d.ts.map

package/dist/pptx/render/shape-adjustment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjustment.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/shape-adjustment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAM9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAIrE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAC1C,eAAO,MAAM,6BAA6B,QAAQ,CAAC;AAEnD,0EAA0E;AAC1E,MAAM,WAAW,+BAA+B;IAC/C,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACjC;AAED,kEAAkE;AAClE,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACjC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAMtF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAK/E;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mCAAmC,CAClD,OAAO,EAAE,WAAW,GAClB,+BAA+B,EAAE,CAqBnC;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CACjD,OAAO,EAAE,WAAW,GAClB,+BAA+B,GAAG,IAAI,CAExC;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC7C,KAAK,EAAE,wBAAwB,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACR,MAAM,CAkBR;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,wBAAwB,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACR,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,+BAA+B,EAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACb,wBAAwB,CAe1B"}