@pptx-studio/render-dom 0.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Dewiride Technologies
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,43 @@
+PPTX Studio
+Copyright 2026 Dewiride Technologies
+
+This product includes software developed at Dewiride Technologies
+(https://github.com/Dewiride-Open-Source/Dewiride-PPTX-Studio).
+
+--------------------------------------------------------------------------------
+Third-party material redistributed in this repository
+--------------------------------------------------------------------------------
+
+Entries are added here at the moment the material lands, not at release time.
+
+  * Apache POI
+      Copyright The Apache Software Foundation
+      Licensed under the Apache License, Version 2.0.
+      https://poi.apache.org/
+
+    @pptx-studio/geometry contains the 187 DrawingML preset shape definitions,
+    transcoded at build time from POI's presetShapeDefinitions.xml by
+    tools/geometry-codegen. The transcoded form is a re-encoding of that file's
+    content and carries POI's copyright.
+
+    The file itself is not redistributed in this repository. The generated
+    modules in packages/geometry/src/presets record the SHA-256 of the exact
+    input they were produced from:
+
+      presetShapeDefinitions.xml, 538970 bytes
+      sha256 4a762444d8d85876881c02a5b1dedf6f73006fcd8acb7b4e393435615b37c780
+
+--------------------------------------------------------------------------------
+Attributions the plan commits us to, listed so the obligation is visible before
+the code arrives
+--------------------------------------------------------------------------------
+
+  * Pattern fill tiles (sub-phase 2.7) are generated from Mono libgdiplus.
+      libgdiplus - Copyright Novell, Inc. and contributors - MIT
+
+  * Metric-compatible substitute fonts ship in a separate package,
+    @pptx-studio/fonts-metric-compat, under SIL OFL 1.1 with its own
+    OFL.txt and reserved-font-name handling. They are deliberately kept out
+    of this Apache-2.0 tree so the licence boundary is a package boundary.
+
+See LEGAL.md for the clean-room record and the reimplementation basis.

package/README.md

@@ -0,0 +1,69 @@
+# @pptx-studio/render-dom
+
+The live renderer: one `<svg>` per slide, built as real elements.
+
+Sub-phase 2.10. Every fact about DrawingML this package draws on lives in
+[`@pptx-studio/render-svg`](../render-svg#readme) and was measured against Microsoft PowerPoint in
+experiment C6.
+
+## One tree, two renderers
+
+The plan asks for two renderers "over the same layout engine", so that a thumbnail and the editor
+cannot disagree about what is on the screen. Sharing a _layout_ is not enough for that on its own:
+emitting a `<linearGradient>` twice, once as text and once through `createElementNS`, is two chances
+to write the same gradient wrong in two different ways.
+
+So the shared surface goes a level deeper. `render-svg` builds a node tree and serialises it; this
+builds the identical tree and instantiates it. The suite asserts that the browser's own
+`XMLSerializer` over the mounted nodes returns the string emitter's output character for character.
+
+## The namespace
+
+`document.createElement('path')` makes an HTML element that happens to be spelled `path`, and it
+draws nothing at all — silently, with no error anywhere. Every element here goes through
+`createElementNS`. Attributes are the mirror image: they belong to no namespace and go through plain
+`setAttribute`.
+
+The suite runs in real Chromium rather than jsdom, which is the repository's standing choice and
+earns it here: the test calls `getTotalLength()` on the mounted path, which an HTML element cannot
+answer.
+
+## Zoom is a transform, never a re-layout
+
+The mounted `<svg>` carries a `viewBox` in EMU and is sized in CSS pixels, so scaling it is one
+attribute and no arithmetic — `resize()` writes `width` and `height` and nothing else moves. The
+plan's rule is the reason: font metrics are not linear in point size, so a renderer that re-lays out
+per zoom level changes its line breaks as the user zooms.
+
+## Using it
+
+```ts
+import { mountSlide } from '@pptx-studio/render-dom';
+
+const mounted = mountSlide(host, slide, { cx: 12192000, cy: 6858000 }, { width: 960, height: 540 });
+mounted.element(shape.cNvPrId); // the element drawing one shape, for hit-testing
+mounted.resize(1280, 720);
+mounted.unmount();
+```
+
+`document` may be passed explicitly, because this package has to work in a Web Worker with no global
+one — and because a test that has to stub a global is a test that can pass for the wrong reason.
+
+## What it does not do yet
+
+Text (3.8), the overlay canvas and adjust-handle chrome (2.11), selection and gestures (Phase 5),
+and slide virtualization (12.1). The host is emptied on mount; anything a caller wants beside the
+slide is a sibling of the host, not a child of it.
+
+## The text layer
+
+`mountTextLayer` builds an HTML layer over the slide from the identical `TextBlock`
+`@pptx-studio/render-svg` emits: one div per shape, one per line, a span per piece, and the same
+rule rectangles. Real text nodes, so selection, an IME and a screen reader all work on them.
+
+There is one set of line boxes and both renderers read it, which is what stops them drifting. The
+one place the HTML layer is not exact is the baseline: a browser puts an inline baseline a
+half-leading plus an ascent below the line box, from font metrics it has rounded to whole pixels,
+so the `line-height` that reconciles the two lands within one CSS pixel and no closer. The SVG
+emitter, where a baseline is a coordinate, is exact — which is the right way round, since that is
+what thumbnails and export go through.

package/dist/index.d.ts

@@ -0,0 +1,173 @@
+import { OverlayOptions, Placed, RenderOptions, ShapeOverlay, SlideSize, SvgNode, TextBlock } from "@pptx-studio/render-svg";
+import { Point, PresetGuide } from "@pptx-studio/geometry";
+import { Sheet } from "@pptx-studio/model";
+//#region src/errors.d.ts
+/**
+ * Every failure in this package is a `RenderDomError` with a code.
+ *
+ * There are only two, and both mean the *caller* asked for something
+ * impossible: a host that is not an element, or an element with no document to
+ * build in. Everything about the slide itself is `render-svg`'s to refuse, and
+ * this package never re-decides it.
+ */
+type RenderDomErrorCode =
+/** `mountSlide` was handed something that is not an element. */
+'RENDER_DOM_NO_HOST' |
+/** The host is detached and no `document` was passed. */
+'RENDER_DOM_NO_DOCUMENT';
+declare const RENDER_DOM_ERROR_CODES: readonly RenderDomErrorCode[];
+declare class RenderDomError extends Error {
+  readonly code: RenderDomErrorCode;
+  constructor(code: RenderDomErrorCode, message: string);
+}
+declare function isRenderDomError(value: unknown): value is RenderDomError;
+//#endregion
+//#region src/mount.d.ts
+/**
+ * One node into one element. Exported because the debug overlay wants it too.
+ *
+ * A number goes through `render-svg`'s own `num`, not `String`. That is the
+ * whole "one tree, two renderers" claim in one line: the string emitter rounds
+ * to three decimals and normalises `-0`, so a DOM path using `String` would
+ * write `117158.34312` where a thumbnail wrote `117158.343`. Every coordinate
+ * in a slide render happens to be a whole number of EMU, which is why this went
+ * unnoticed until the overlay's text rectangle - the first fractional one -
+ * disagreed at the fourth decimal.
+ */
+declare function createNode(document: Document, node: SvgNode): Node;
+interface MountOptions extends RenderOptions {
+  /**
+   * The `document` to build in.
+   *
+   * Passed rather than reached for, because this package must work in a Web
+   * Worker with an `OffscreenCanvas` and no global `document` - and because a
+   * test that has to stub a global is a test that can pass for the wrong reason.
+   */
+  readonly document?: Document;
+}
+interface MountedSlide {
+  readonly root: SVGSVGElement;
+  readonly placed: readonly Placed[];
+  /** The element drawing a given `p:cNvPr/@id`, for hit-testing and selection. */
+  element(cNvPrId: number): SVGElement | null;
+  /** Resize without re-laying anything out: the viewBox does the work. */
+  resize(width: number, height: number): void;
+  /** Detach from the host. The nodes stay valid, so a caller may re-attach. */
+  unmount(): void;
+}
+/**
+ * Render a sheet into a host element.
+ *
+ * The host is emptied first. Anything a caller wants to keep beside the slide -
+ * the overlay canvas of 2.11, the text layer of 3.8 - is a sibling of the host,
+ * not a child of it.
+ */
+declare function mountSlide(host: Element, sheet: Sheet, size: SlideSize, options?: MountOptions): MountedSlide;
+/**
+ * The same slide as a string, from this package.
+ *
+ * A convenience rather than a second implementation: it calls `render-svg`'s
+ * serializer on the same tree `mountSlide` instantiates, which is the property
+ * the tests check.
+ */
+declare function renderSlideMarkup(sheet: Sheet, size: SlideSize, options?: RenderOptions): string;
+//#endregion
+//#region src/overlay.d.ts
+/** What a completed drag produced. */
+interface HandleEdit {
+  /** Which `a:ahLst` entry was dragged. */
+  readonly handle: number;
+  /** The adjust values this handle controls, rounded as the file will hold them. */
+  readonly adjust: Readonly<Record<string, number>>;
+  /** The shape's whole `a:avLst` after the edit, ready to write back. */
+  readonly avLst: readonly PresetGuide[];
+}
+interface OverlayMountOptions extends OverlayOptions {
+  readonly document?: Document;
+  /** Called on every pointer move during a drag, and once more on release. */
+  onChange?: (edit: HandleEdit) => void;
+  /** Called once on release. */
+  onCommit?: (edit: HandleEdit) => void;
+}
+interface MountedOverlay {
+  readonly root: SVGGElement;
+  readonly overlay: ShapeOverlay;
+  /** Redraw against a new placement - after a drag, or a resize. */
+  update(placed: Placed): void;
+  /** True while a handle is being dragged. */
+  dragging(): boolean;
+  unmount(): void;
+}
+/**
+ * A point in the host `<svg>`'s user space - EMU - from a pointer event.
+ *
+ * Through the SVG CTM rather than by arithmetic on `getBoundingClientRect`,
+ * because the slide may be inside any number of CSS transforms and the browser
+ * already knows the composed matrix. `getScreenCTM` returns null for an element
+ * that is not being rendered, which a drag cannot reach but a stray event can.
+ */
+declare function slidePoint(root: SVGSVGElement, clientX: number, clientY: number): Point | null;
+/**
+ * The `a:avLst` a drag leaves behind.
+ *
+ * The dragged guides replace their namesakes and everything else is kept in
+ * place, because an `a:avLst` is an ordered list and a shape with three adjusts
+ * whose second one moves must still write three, in order. A guide the shape did
+ * not previously declare is appended: the preset's default was in force and the
+ * drag has just overridden it.
+ */
+declare function mergeAdjust(avLst: readonly PresetGuide[], adjust: Readonly<Record<string, number>>): readonly PresetGuide[];
+/**
+ * Draw the overlay for one shape into a host `<svg>`, and make its handles drag.
+ *
+ * The host must be the same `<svg>` the slide is in, because the overlay is
+ * emitted in slide coordinates and carries the shape's own transform - the same
+ * arrangement `mountSlide` produces, so an editor appends this to that root.
+ */
+declare function mountOverlay(root: SVGSVGElement, placed: Placed, options?: OverlayMountOptions): MountedOverlay;
+//#endregion
+//#region src/text/layer.d.ts
+/** A slide's size in points, which is what a block's coordinates are in. */
+interface LayerSize {
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+/** One shape's text, with the frame it is drawn in. */
+interface LayerBlock {
+  readonly block: TextBlock;
+  /** The shape's frame, in points on the slide. */
+  readonly leftPt: number;
+  readonly topPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  /** `p:cNvPr/@id`, so a caller can find the element for a shape. */
+  readonly cNvPrId: number;
+  readonly name?: string | undefined;
+}
+interface TextLayerOptions {
+  readonly document?: Document | undefined;
+  /** CSS pixels per point. One transform, never a re-layout. */
+  readonly scale?: number | undefined;
+  /** Let the layer take pointer events. Off by default: the SVG hit-tests. */
+  readonly interactive?: boolean | undefined;
+}
+interface MountedTextLayer {
+  readonly root: HTMLElement;
+  /** The element holding one shape's text. */
+  element(cNvPrId: number): HTMLElement | null;
+  /** Rescale without re-laying anything out. */
+  resize(scale: number): void;
+  unmount(): void;
+}
+/**
+ * Mount a text layer into a host, over a slide of `size` points.
+ *
+ * The host is emptied first. The layer is sized in points and scaled with one
+ * transform, which is the plan's rule: font metrics are not linear in point
+ * size, so a renderer that re-laid out per zoom would change its line breaks as
+ * the user zoomed.
+ */
+declare function mountTextLayer(host: Element, blocks: readonly LayerBlock[], size: LayerSize, options?: TextLayerOptions): MountedTextLayer;
+//#endregion
+export { type HandleEdit, type LayerBlock, type LayerSize, type MountOptions, type MountedOverlay, type MountedSlide, type MountedTextLayer, type OverlayMountOptions, RENDER_DOM_ERROR_CODES, RenderDomError, type RenderDomErrorCode, type TextLayerOptions, createNode, isRenderDomError, mergeAdjust, mountOverlay, mountSlide, mountTextLayer, renderSlideMarkup, slidePoint };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/mount.ts","../src/overlay.ts","../src/text/layer.ts"],"mappings":";;;;;;;;;;;;KASY;;;;;cAMC,iCAAiC;cAKjC,uBAAuB;WACzB,MAAM;EAEH,YAAA,MAAM,oBAAoB;;iBAOxB,iBAAiB,iBAAiB,SAAS;;;;;;;;;;;;;;iBC6B3C,WAAW,UAAU,UAAU,MAAM,UAAU;UAW9C,qBAAqB;;;;;;;;WAQ3B,WAAW;;UAGL;WACN,MAAM;WACN,iBAAiB;;EAE1B,QAAQ,kBAAkB;;EAE1B,OAAO,eAAe;;EAEtB;;;;;;;;;iBAmBc,WACd,MAAM,SACN,OAAO,OACP,MAAM,WACN,UAAS,eACR;;;;;;;;iBA2Ca,kBACd,OAAO,OACP,MAAM,WACN,UAAS;;;;UCpHM;;WAEN;;WAEA,QAAQ,SAAS;;WAEjB,gBAAgB;;UAGV,4BAA4B;WAClC,WAAW;;EAEpB,YAAY,MAAM;;EAElB,YAAY,MAAM;;UAGH;WACN,MAAM;WACN,SAAS;;EAElB,OAAO,QAAQ;;EAEf;EACA;;;;;;;;;;iBAWc,WAAW,MAAM,eAAe,iBAAiB,kBAAkB;;;;;;;;;;iBAmBnE,YACd,gBAAgB,eAChB,QAAQ,SAAS,mCACP;;;;;;;;iBAsBI,aACd,MAAM,eACN,QAAQ,QACR,UAAS,sBACR;;;;UC9Fc;WACN;WACA;;;UAIM;WACN,OAAO;;WAEP;WACA;WACA;WACA;;WAEA;WACA;;UAGM;WACN,WAAW;;WAEX;;WAEA;;UAGM;WACN,MAAM;;EAEf,QAAQ,kBAAkB;;EAE1B,OAAO;EACP;;;;;;;;;;iBAiJc,eACd,MAAM,SACN,iBAAiB,cACjB,MAAM,WACN,UAAS,mBACR"}

package/dist/index.js

@@ -0,0 +1,477 @@
+import { inverseFramePoint, num, serializeSvg, shapeOverlay, slideNode } from "@pptx-studio/render-svg";
+import { dragHandle } from "@pptx-studio/geometry";
+import { toCss } from "@pptx-studio/paint";
+//#region src/errors.ts
+const RENDER_DOM_ERROR_CODES = ["RENDER_DOM_NO_HOST", "RENDER_DOM_NO_DOCUMENT"];
+var RenderDomError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "RenderDomError";
+		this.code = code;
+	}
+};
+function isRenderDomError(value) {
+	return value instanceof RenderDomError;
+}
+//#endregion
+//#region src/mount.ts
+/**
+* The live renderer: the same node tree as `render-svg`, as real elements.
+*
+* ## Why this is thirty lines of DOM and not a second renderer
+*
+* The plan asks for two renderers "over the same layout engine", so that a
+* thumbnail and the editor cannot disagree about what is on the screen. Sharing
+* a *layout* is not enough for that on its own: emitting a `<linearGradient>`
+* twice, once as text and once as `createElementNS`, is two chances to write the
+* same gradient wrong in two different ways.
+*
+* So the shared surface goes a level deeper. `render-svg` builds a node tree and
+* serialises it; this builds the identical tree and instantiates it. Everything
+* either of them knows about DrawingML is in that tree before either touches it,
+* and the only thing this file decides is which DOM call makes a node.
+*
+* ## The namespace, and the four attributes that need their own
+*
+* `document.createElement` makes an HTML element that happens to be spelled
+* `path`, and it draws nothing at all - silently. Every element here goes
+* through `createElementNS` with the SVG namespace. Attributes are the mirror
+* image: they belong to **no** namespace and must go through `setAttribute`,
+* with the single exception of `xlink:href`, which this package never emits.
+*
+* ## Zoom is a transform, never a re-layout
+*
+* The mounted `<svg>` carries a `viewBox` in EMU and is sized in CSS pixels, so
+* scaling it is one attribute and no arithmetic. The plan's rule is the reason:
+* font metrics are not linear in point size, so a renderer that re-lays out per
+* zoom level changes the line breaks as the user zooms.
+*/
+const SVG_NS = "http://www.w3.org/2000/svg";
+/**
+* One node into one element. Exported because the debug overlay wants it too.
+*
+* A number goes through `render-svg`'s own `num`, not `String`. That is the
+* whole "one tree, two renderers" claim in one line: the string emitter rounds
+* to three decimals and normalises `-0`, so a DOM path using `String` would
+* write `117158.34312` where a thumbnail wrote `117158.343`. Every coordinate
+* in a slide render happens to be a whole number of EMU, which is why this went
+* unnoticed until the overlay's text rectangle - the first fractional one -
+* disagreed at the fourth decimal.
+*/
+function createNode(document, node) {
+	if (node.kind === "text") return document.createTextNode(node.text);
+	const el = document.createElementNS(SVG_NS, node.tag);
+	for (const [name, value] of Object.entries(node.attrs)) {
+		if (value === null || value === void 0) continue;
+		el.setAttribute(name, typeof value === "number" ? num(value) : value);
+	}
+	for (const child of node.children) el.appendChild(createNode(document, child));
+	return el;
+}
+function ownerDocument(host, options) {
+	const document = options.document ?? host.ownerDocument;
+	if (document === null || document === void 0) throw new RenderDomError("RENDER_DOM_NO_DOCUMENT", "the host element has no ownerDocument");
+	return document;
+}
+/**
+* Render a sheet into a host element.
+*
+* The host is emptied first. Anything a caller wants to keep beside the slide -
+* the overlay canvas of 2.11, the text layer of 3.8 - is a sibling of the host,
+* not a child of it.
+*/
+function mountSlide(host, sheet, size, options = {}) {
+	if (host === null || typeof host !== "object" || typeof host.appendChild !== "function") throw new RenderDomError("RENDER_DOM_NO_HOST", "mountSlide needs an element to build into");
+	const document = ownerDocument(host, options);
+	const rendered = slideNode(sheet, size, options);
+	const root = createNode(document, rendered.node);
+	host.replaceChildren(root);
+	const byId = /* @__PURE__ */ new Map();
+	const walk = (node) => {
+		const id = node.getAttribute("data-shape");
+		if (id !== null && !byId.has(Number(id))) byId.set(Number(id), node);
+		for (const child of Array.from(node.children)) walk(child);
+	};
+	walk(root);
+	return {
+		root,
+		placed: rendered.placed,
+		element(cNvPrId) {
+			return byId.get(cNvPrId) ?? null;
+		},
+		resize(width, height) {
+			root.setAttribute("width", String(width));
+			root.setAttribute("height", String(height));
+		},
+		unmount() {
+			root.remove();
+		}
+	};
+}
+/**
+* The same slide as a string, from this package.
+*
+* A convenience rather than a second implementation: it calls `render-svg`'s
+* serializer on the same tree `mountSlide` instantiates, which is the property
+* the tests check.
+*/
+function renderSlideMarkup(sheet, size, options = {}) {
+	return serializeSvg(slideNode(sheet, size, options).node);
+}
+//#endregion
+//#region src/overlay.ts
+/**
+* The debug overlay, live: the same nodes `render-svg` builds, plus a pointer.
+*
+* Sub-phase 2.11. Everything drawn here comes from `shapeOverlay`, so the
+* handle a user grabs is at the position a thumbnail would have drawn it - the
+* overlay is not a second opinion about where the geometry went. What this file
+* adds is the four things a pointer needs and a node tree cannot have: an
+* element to mount into, hit-testing, the drag, and the inverse transform that
+* gets a pointer from the slide into the shape's own space.
+*
+* ## Slide space, shape space, and why the inverse has to be exact
+*
+* A shape's adjust handles live in *its* coordinates: `(0, 0)` at the top left
+* of `a:ext`, before any rotation or mirroring. A pointer arrives in the
+* slide's. `inverseFramePoint` undoes exactly what `frameTransform` did, in the
+* reverse order - so the mirror is undone *after* the rotation, because it was
+* applied *before* it. Get that backwards and handles work perfectly on every
+* unrotated shape and drift on precisely the flipped, turned ones where a user
+* would never guess the renderer was at fault.
+*
+* ## The drag writes adjust values, not positions
+*
+* `dragHandle` inverts the handle's own formula and returns `{ guideName:
+* value }` for the guides that handle controls and nothing else, already
+* rounded to the integers the file will hold. So a drag produces an `a:avLst`
+* edit, the shape is re-evaluated from it, and the handle lands wherever the
+* geometry says it lands - which is why a handle confined to a curve does not
+* follow the pointer off it. That is the correct behaviour and PowerPoint's.
+*/
+/**
+* A point in the host `<svg>`'s user space - EMU - from a pointer event.
+*
+* Through the SVG CTM rather than by arithmetic on `getBoundingClientRect`,
+* because the slide may be inside any number of CSS transforms and the browser
+* already knows the composed matrix. `getScreenCTM` returns null for an element
+* that is not being rendered, which a drag cannot reach but a stray event can.
+*/
+function slidePoint(root, clientX, clientY) {
+	const ctm = root.getScreenCTM();
+	if (ctm === null) return null;
+	const point = root.createSVGPoint();
+	point.x = clientX;
+	point.y = clientY;
+	const local = point.matrixTransform(ctm.inverse());
+	return {
+		x: local.x,
+		y: local.y
+	};
+}
+/**
+* The `a:avLst` a drag leaves behind.
+*
+* The dragged guides replace their namesakes and everything else is kept in
+* place, because an `a:avLst` is an ordered list and a shape with three adjusts
+* whose second one moves must still write three, in order. A guide the shape did
+* not previously declare is appended: the preset's default was in force and the
+* drag has just overridden it.
+*/
+function mergeAdjust(avLst, adjust) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = avLst.map((guide) => {
+		const value = adjust[guide.name];
+		if (value === void 0) return guide;
+		seen.add(guide.name);
+		return {
+			name: guide.name,
+			fmla: ["val", String(Math.round(value))]
+		};
+	});
+	for (const [name, value] of Object.entries(adjust)) {
+		if (seen.has(name)) continue;
+		merged.push({
+			name,
+			fmla: ["val", String(Math.round(value))]
+		});
+	}
+	return merged;
+}
+/**
+* Draw the overlay for one shape into a host `<svg>`, and make its handles drag.
+*
+* The host must be the same `<svg>` the slide is in, because the overlay is
+* emitted in slide coordinates and carries the shape's own transform - the same
+* arrangement `mountSlide` produces, so an editor appends this to that root.
+*/
+function mountOverlay(root, placed, options = {}) {
+	if (root === null || typeof root !== "object" || typeof root.appendChild !== "function") throw new RenderDomError("RENDER_DOM_NO_HOST", "mountOverlay needs the slide <svg> to build in");
+	const document = options.document ?? root.ownerDocument;
+	if (document === null || document === void 0) throw new RenderDomError("RENDER_DOM_NO_DOCUMENT", "the host element has no ownerDocument");
+	let current = placed;
+	let overlay = shapeOverlay(current, options);
+	let group = createNode(document, overlay.node);
+	root.appendChild(group);
+	let active = null;
+	let pointer = null;
+	function edit(at, index) {
+		const source = current.geometrySource;
+		const handle = overlay.handles.find((h) => h.index === index);
+		if (source === null || handle === void 0) return null;
+		const local = inverseFramePoint(current.frame, at);
+		const adjust = dragHandle(source.geometry, {
+			w: current.frame.cx,
+			h: current.frame.cy
+		}, handle.handle, local, { adjust: source.adjust });
+		if (Object.keys(adjust).length === 0) return null;
+		return {
+			handle: index,
+			adjust,
+			avLst: mergeAdjust(source.adjust, adjust)
+		};
+	}
+	/**
+	* Hold the pointer for the duration of the drag.
+	*
+	* On the root rather than on the handle, because the handle element is
+	* replaced on every update and a captured element that leaves the tree takes
+	* the capture with it - the drag would stop the moment the shape redrew.
+	*
+	* `setPointerCapture` throws `NotFoundError` for a pointer that is no longer
+	* active, which is reachable whenever the button is released between the
+	* event being queued and this running. Losing the capture degrades the drag
+	* to one that stops at the window edge; throwing would abandon it entirely.
+	*/
+	function capture(pointerId) {
+		try {
+			root.setPointerCapture(pointerId);
+		} catch {}
+	}
+	function onPointerDown(event) {
+		const owner = event.target?.closest?.("[data-role=\"handle\"]");
+		const index = owner?.getAttribute("data-handle");
+		if (index === null || index === void 0 || owner?.getAttribute("data-axes") === "") return;
+		active = Number(index);
+		pointer = event.pointerId;
+		capture(event.pointerId);
+		event.preventDefault();
+	}
+	function onPointerMove(event) {
+		if (active === null || event.pointerId !== pointer) return;
+		const at = slidePoint(root, event.clientX, event.clientY);
+		if (at === null) return;
+		const result = edit(at, active);
+		if (result !== null) options.onChange?.(result);
+	}
+	function onPointerUp(event) {
+		if (active === null || event.pointerId !== pointer) return;
+		const at = slidePoint(root, event.clientX, event.clientY);
+		const result = at === null ? null : edit(at, active);
+		active = null;
+		pointer = null;
+		if (root.hasPointerCapture(event.pointerId)) root.releasePointerCapture(event.pointerId);
+		if (result !== null) options.onCommit?.(result);
+	}
+	const listening = new AbortController();
+	const on = { signal: listening.signal };
+	root.addEventListener("pointerdown", onPointerDown, on);
+	root.addEventListener("pointermove", onPointerMove, on);
+	root.addEventListener("pointerup", onPointerUp, on);
+	root.addEventListener("pointercancel", onPointerUp, on);
+	return {
+		get root() {
+			return group;
+		},
+		get overlay() {
+			return overlay;
+		},
+		update(next) {
+			current = next;
+			overlay = shapeOverlay(current, options);
+			const replacement = createNode(document, overlay.node);
+			group.replaceWith(replacement);
+			group = replacement;
+		},
+		dragging() {
+			return active !== null;
+		},
+		unmount() {
+			listening.abort();
+			group.remove();
+		}
+	};
+}
+//#endregion
+//#region src/text/layer.ts
+function px(value) {
+	return `${String(Math.round(value * 1e3) / 1e3)}px`;
+}
+/** Through `toCss`, because `Rgba` channels are 0..1 and not bytes. */
+function css(color) {
+	return color === null ? "inherit" : toCss(color);
+}
+/** The dash pattern a rule is painted with, in multiples of its thickness. */
+const DASHES = {
+	dotted: [1, 2],
+	dashed: [4, 3],
+	longDashed: [8, 3],
+	dotDash: [
+		4,
+		3,
+		1,
+		3
+	],
+	dotDotDash: [
+		1,
+		3,
+		1,
+		3,
+		4,
+		3
+	]
+};
+function ruleElement(document, rule, x, baseline, color) {
+	const el = document.createElement("div");
+	const style = el.style;
+	style.position = "absolute";
+	style.left = px(x + rule.leftPt);
+	style.top = px(baseline + rule.topPt);
+	style.width = px(rule.widthPt);
+	style.height = px(rule.thickness);
+	const dash = DASHES[rule.pattern];
+	if (dash === void 0) {
+		style.background = color;
+		return el;
+	}
+	const on = (dash[0] ?? 1) * rule.thickness;
+	const off = (dash[1] ?? 1) * rule.thickness;
+	style.background = `repeating-linear-gradient(to right, ${color} 0 ${px(on)}, transparent ${px(on)} ${px(on + off)})`;
+	return el;
+}
+function pieceElement(document, piece) {
+	const el = document.createElement("span");
+	const style = el.style;
+	style.fontFamily = piece.cssFamily;
+	style.fontSize = px(piece.font.sz / 100);
+	if (piece.font.bold === true) style.fontWeight = "bold";
+	if (piece.font.italic === true) style.fontStyle = "italic";
+	if (piece.font.spc !== void 0 && piece.font.spc !== 0) style.letterSpacing = px(piece.font.spc / 100);
+	style.color = css(piece.color);
+	if (piece.highlight !== null) style.background = css(piece.highlight);
+	if (piece.risePt !== 0) {
+		style.position = "relative";
+		style.top = px(-piece.risePt);
+	}
+	el.textContent = piece.text;
+	return el;
+}
+/**
+* One glyph stood upright inside a turned line, placed from its own pen.
+*
+* The span is laid out unrotated with its baseline `sizePt` below its top - what
+* `UprightGlyph.strutPt` solves for - and then turned a quarter back about that
+* point, so the pen lands where the SVG emitter puts the same glyph.
+*/
+function uprightElement(document, piece, glyph) {
+	const el = pieceElement(document, piece);
+	const style = el.style;
+	const sizePt = piece.font.sz / 100;
+	style.position = "absolute";
+	style.left = px(glyph.alongPt - piece.risePt);
+	style.top = px(glyph.acrossPt - sizePt);
+	style.lineHeight = px(glyph.strutPt);
+	style.transformOrigin = `0 ${px(sizePt)}`;
+	style.transform = "rotate(-90deg)";
+	el.textContent = glyph.text;
+	return el;
+}
+function lineElement(document, line) {
+	const el = document.createElement("div");
+	const style = el.style;
+	style.position = "absolute";
+	style.left = px(line.leftPt);
+	style.top = px(line.topPt);
+	style.width = px(line.widthPt);
+	style.height = px(line.heightPt);
+	style.lineHeight = px(line.strutPt);
+	style.whiteSpace = "pre";
+	if (line.wordSpacingPt !== 0) style.wordSpacing = px(line.wordSpacingPt);
+	for (const piece of line.pieces) if (piece.upright.length > 0) for (const glyph of piece.upright) el.appendChild(uprightElement(document, piece, glyph));
+	else el.appendChild(pieceElement(document, piece));
+	const baseline = line.baselinePt - line.topPt;
+	for (const piece of line.pieces) {
+		const color = css(piece.color);
+		for (const rule of piece.rules) el.appendChild(ruleElement(document, rule, piece.leftPt, baseline - piece.risePt, color));
+	}
+	return el;
+}
+function blockElement(document, entry) {
+	const el = document.createElement("div");
+	const style = el.style;
+	style.position = "absolute";
+	style.left = px(entry.leftPt);
+	style.top = px(entry.topPt);
+	style.width = px(entry.widthPt);
+	style.height = px(entry.heightPt);
+	if (entry.block.turnDeg !== 0) {
+		style.transformOrigin = "50% 50%";
+		style.transform = `rotate(${String(entry.block.turnDeg)}deg)`;
+	}
+	el.setAttribute("data-text", String(entry.cNvPrId));
+	if (entry.name !== void 0 && entry.name !== "") el.setAttribute("data-name", entry.name);
+	for (const line of entry.block.lines) el.appendChild(lineElement(document, line));
+	return el;
+}
+/**
+* Mount a text layer into a host, over a slide of `size` points.
+*
+* The host is emptied first. The layer is sized in points and scaled with one
+* transform, which is the plan's rule: font metrics are not linear in point
+* size, so a renderer that re-laid out per zoom would change its line breaks as
+* the user zoomed.
+*/
+function mountTextLayer(host, blocks, size, options = {}) {
+	if (host === null || typeof host !== "object" || typeof host.appendChild !== "function") throw new RenderDomError("RENDER_DOM_NO_HOST", "mountTextLayer needs an element to build into");
+	const document = options.document ?? host.ownerDocument;
+	if (document === null || document === void 0) throw new RenderDomError("RENDER_DOM_NO_DOCUMENT", "the host element has no ownerDocument");
+	const root = document.createElement("div");
+	const style = root.style;
+	style.position = "absolute";
+	style.left = "0";
+	style.top = "0";
+	style.width = px(size.widthPt);
+	style.height = px(size.heightPt);
+	style.transformOrigin = "0 0";
+	style.pointerEvents = options.interactive === true ? "auto" : "none";
+	root.setAttribute("data-role", "text-layer");
+	const byId = /* @__PURE__ */ new Map();
+	for (const entry of blocks) {
+		if (entry.block.lines.length === 0) continue;
+		const el = blockElement(document, entry);
+		byId.set(entry.cNvPrId, el);
+		root.appendChild(el);
+	}
+	const apply = (scale) => {
+		style.transform = scale === 1 ? "" : `scale(${String(scale)})`;
+	};
+	apply(options.scale ?? 1);
+	host.replaceChildren(root);
+	return {
+		root,
+		element(cNvPrId) {
+			return byId.get(cNvPrId) ?? null;
+		},
+		resize(scale) {
+			apply(scale);
+		},
+		unmount() {
+			root.remove();
+		}
+	};
+}
+//#endregion
+export { RENDER_DOM_ERROR_CODES, RenderDomError, createNode, isRenderDomError, mergeAdjust, mountOverlay, mountSlide, mountTextLayer, renderSlideMarkup, slidePoint };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/errors.ts","../src/mount.ts","../src/overlay.ts","../src/text/layer.ts"],"sourcesContent":["/**\n * Every failure in this package is a `RenderDomError` with a code.\n *\n * There are only two, and both mean the *caller* asked for something\n * impossible: a host that is not an element, or an element with no document to\n * build in. Everything about the slide itself is `render-svg`'s to refuse, and\n * this package never re-decides it.\n */\n\nexport type RenderDomErrorCode =\n  /** `mountSlide` was handed something that is not an element. */\n  | 'RENDER_DOM_NO_HOST'\n  /** The host is detached and no `document` was passed. */\n  | 'RENDER_DOM_NO_DOCUMENT';\n\nexport const RENDER_DOM_ERROR_CODES: readonly RenderDomErrorCode[] = [\n  'RENDER_DOM_NO_HOST',\n  'RENDER_DOM_NO_DOCUMENT',\n];\n\nexport class RenderDomError extends Error {\n  readonly code: RenderDomErrorCode;\n\n  constructor(code: RenderDomErrorCode, message: string) {\n    super(message);\n    this.name = 'RenderDomError';\n    this.code = code;\n  }\n}\n\nexport function isRenderDomError(value: unknown): value is RenderDomError {\n  return value instanceof RenderDomError;\n}\n","/**\n * The live renderer: the same node tree as `render-svg`, as real elements.\n *\n * ## Why this is thirty lines of DOM and not a second renderer\n *\n * The plan asks for two renderers \"over the same layout engine\", so that a\n * thumbnail and the editor cannot disagree about what is on the screen. Sharing\n * a *layout* is not enough for that on its own: emitting a `<linearGradient>`\n * twice, once as text and once as `createElementNS`, is two chances to write the\n * same gradient wrong in two different ways.\n *\n * So the shared surface goes a level deeper. `render-svg` builds a node tree and\n * serialises it; this builds the identical tree and instantiates it. Everything\n * either of them knows about DrawingML is in that tree before either touches it,\n * and the only thing this file decides is which DOM call makes a node.\n *\n * ## The namespace, and the four attributes that need their own\n *\n * `document.createElement` makes an HTML element that happens to be spelled\n * `path`, and it draws nothing at all - silently. Every element here goes\n * through `createElementNS` with the SVG namespace. Attributes are the mirror\n * image: they belong to **no** namespace and must go through `setAttribute`,\n * with the single exception of `xlink:href`, which this package never emits.\n *\n * ## Zoom is a transform, never a re-layout\n *\n * The mounted `<svg>` carries a `viewBox` in EMU and is sized in CSS pixels, so\n * scaling it is one attribute and no arithmetic. The plan's rule is the reason:\n * font metrics are not linear in point size, so a renderer that re-lays out per\n * zoom level changes the line breaks as the user zooms.\n */\n\nimport {\n  num,\n  serializeSvg,\n  slideNode,\n  type Placed,\n  type RenderOptions,\n  type SlideSize,\n  type SvgElement,\n  type SvgNode,\n} from '@pptx-studio/render-svg';\nimport type { Sheet } from '@pptx-studio/model';\n\nimport { RenderDomError } from './errors.js';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n\n/**\n * One node into one element. Exported because the debug overlay wants it too.\n *\n * A number goes through `render-svg`'s own `num`, not `String`. That is the\n * whole \"one tree, two renderers\" claim in one line: the string emitter rounds\n * to three decimals and normalises `-0`, so a DOM path using `String` would\n * write `117158.34312` where a thumbnail wrote `117158.343`. Every coordinate\n * in a slide render happens to be a whole number of EMU, which is why this went\n * unnoticed until the overlay's text rectangle - the first fractional one -\n * disagreed at the fourth decimal.\n */\nexport function createNode(document: Document, node: SvgNode): Node {\n  if (node.kind === 'text') return document.createTextNode(node.text);\n  const el = document.createElementNS(SVG_NS, node.tag);\n  for (const [name, value] of Object.entries(node.attrs)) {\n    if (value === null || value === undefined) continue;\n    el.setAttribute(name, typeof value === 'number' ? num(value) : value);\n  }\n  for (const child of node.children) el.appendChild(createNode(document, child));\n  return el;\n}\n\nexport interface MountOptions extends RenderOptions {\n  /**\n   * The `document` to build in.\n   *\n   * Passed rather than reached for, because this package must work in a Web\n   * Worker with an `OffscreenCanvas` and no global `document` - and because a\n   * test that has to stub a global is a test that can pass for the wrong reason.\n   */\n  readonly document?: Document;\n}\n\nexport interface MountedSlide {\n  readonly root: SVGSVGElement;\n  readonly placed: readonly Placed[];\n  /** The element drawing a given `p:cNvPr/@id`, for hit-testing and selection. */\n  element(cNvPrId: number): SVGElement | null;\n  /** Resize without re-laying anything out: the viewBox does the work. */\n  resize(width: number, height: number): void;\n  /** Detach from the host. The nodes stay valid, so a caller may re-attach. */\n  unmount(): void;\n}\n\nfunction ownerDocument(host: Element, options: MountOptions): Document {\n  const document = options.document ?? host.ownerDocument;\n\n  if (document === null || document === undefined) {\n    throw new RenderDomError('RENDER_DOM_NO_DOCUMENT', 'the host element has no ownerDocument');\n  }\n  return document;\n}\n\n/**\n * Render a sheet into a host element.\n *\n * The host is emptied first. Anything a caller wants to keep beside the slide -\n * the overlay canvas of 2.11, the text layer of 3.8 - is a sibling of the host,\n * not a child of it.\n */\nexport function mountSlide(\n  host: Element,\n  sheet: Sheet,\n  size: SlideSize,\n  options: MountOptions = {},\n): MountedSlide {\n  // `typeof null` is 'object', so the null check has to come first or the\n  // guard reads a property off it and throws the wrong error.\n  if (host === null || typeof host !== 'object' || typeof host.appendChild !== 'function') {\n    throw new RenderDomError('RENDER_DOM_NO_HOST', 'mountSlide needs an element to build into');\n  }\n  const document = ownerDocument(host, options);\n  const rendered = slideNode(sheet, size, options);\n  const root = createNode(document, rendered.node) as SVGSVGElement;\n\n  host.replaceChildren(root);\n\n  const byId = new Map<number, SVGElement>();\n  const walk = (node: Element): void => {\n    const id = node.getAttribute('data-shape');\n    if (id !== null && !byId.has(Number(id))) byId.set(Number(id), node as SVGElement);\n    for (const child of Array.from(node.children)) walk(child);\n  };\n  walk(root);\n\n  return {\n    root,\n    placed: rendered.placed,\n    element(cNvPrId: number): SVGElement | null {\n      return byId.get(cNvPrId) ?? null;\n    },\n    resize(width: number, height: number): void {\n      root.setAttribute('width', String(width));\n      root.setAttribute('height', String(height));\n    },\n    unmount(): void {\n      root.remove();\n    },\n  };\n}\n\n/**\n * The same slide as a string, from this package.\n *\n * A convenience rather than a second implementation: it calls `render-svg`'s\n * serializer on the same tree `mountSlide` instantiates, which is the property\n * the tests check.\n */\nexport function renderSlideMarkup(\n  sheet: Sheet,\n  size: SlideSize,\n  options: RenderOptions = {},\n): string {\n  return serializeSvg(slideNode(sheet, size, options).node);\n}\n\nexport type { SvgElement };\n","/**\n * The debug overlay, live: the same nodes `render-svg` builds, plus a pointer.\n *\n * Sub-phase 2.11. Everything drawn here comes from `shapeOverlay`, so the\n * handle a user grabs is at the position a thumbnail would have drawn it - the\n * overlay is not a second opinion about where the geometry went. What this file\n * adds is the four things a pointer needs and a node tree cannot have: an\n * element to mount into, hit-testing, the drag, and the inverse transform that\n * gets a pointer from the slide into the shape's own space.\n *\n * ## Slide space, shape space, and why the inverse has to be exact\n *\n * A shape's adjust handles live in *its* coordinates: `(0, 0)` at the top left\n * of `a:ext`, before any rotation or mirroring. A pointer arrives in the\n * slide's. `inverseFramePoint` undoes exactly what `frameTransform` did, in the\n * reverse order - so the mirror is undone *after* the rotation, because it was\n * applied *before* it. Get that backwards and handles work perfectly on every\n * unrotated shape and drift on precisely the flipped, turned ones where a user\n * would never guess the renderer was at fault.\n *\n * ## The drag writes adjust values, not positions\n *\n * `dragHandle` inverts the handle's own formula and returns `{ guideName:\n * value }` for the guides that handle controls and nothing else, already\n * rounded to the integers the file will hold. So a drag produces an `a:avLst`\n * edit, the shape is re-evaluated from it, and the handle lands wherever the\n * geometry says it lands - which is why a handle confined to a curve does not\n * follow the pointer off it. That is the correct behaviour and PowerPoint's.\n */\n\nimport { dragHandle, type Point, type PresetGuide } from '@pptx-studio/geometry';\nimport {\n  inverseFramePoint,\n  shapeOverlay,\n  type OverlayOptions,\n  type Placed,\n  type ShapeOverlay,\n} from '@pptx-studio/render-svg';\n\nimport { RenderDomError } from './errors.js';\nimport { createNode } from './mount.js';\n\n/** What a completed drag produced. */\nexport interface HandleEdit {\n  /** Which `a:ahLst` entry was dragged. */\n  readonly handle: number;\n  /** The adjust values this handle controls, rounded as the file will hold them. */\n  readonly adjust: Readonly<Record<string, number>>;\n  /** The shape's whole `a:avLst` after the edit, ready to write back. */\n  readonly avLst: readonly PresetGuide[];\n}\n\nexport interface OverlayMountOptions extends OverlayOptions {\n  readonly document?: Document;\n  /** Called on every pointer move during a drag, and once more on release. */\n  onChange?: (edit: HandleEdit) => void;\n  /** Called once on release. */\n  onCommit?: (edit: HandleEdit) => void;\n}\n\nexport interface MountedOverlay {\n  readonly root: SVGGElement;\n  readonly overlay: ShapeOverlay;\n  /** Redraw against a new placement - after a drag, or a resize. */\n  update(placed: Placed): void;\n  /** True while a handle is being dragged. */\n  dragging(): boolean;\n  unmount(): void;\n}\n\n/**\n * A point in the host `<svg>`'s user space - EMU - from a pointer event.\n *\n * Through the SVG CTM rather than by arithmetic on `getBoundingClientRect`,\n * because the slide may be inside any number of CSS transforms and the browser\n * already knows the composed matrix. `getScreenCTM` returns null for an element\n * that is not being rendered, which a drag cannot reach but a stray event can.\n */\nexport function slidePoint(root: SVGSVGElement, clientX: number, clientY: number): Point | null {\n  const ctm = root.getScreenCTM();\n  if (ctm === null) return null;\n  const point = root.createSVGPoint();\n  point.x = clientX;\n  point.y = clientY;\n  const local = point.matrixTransform(ctm.inverse());\n  return { x: local.x, y: local.y };\n}\n\n/**\n * The `a:avLst` a drag leaves behind.\n *\n * The dragged guides replace their namesakes and everything else is kept in\n * place, because an `a:avLst` is an ordered list and a shape with three adjusts\n * whose second one moves must still write three, in order. A guide the shape did\n * not previously declare is appended: the preset's default was in force and the\n * drag has just overridden it.\n */\nexport function mergeAdjust(\n  avLst: readonly PresetGuide[],\n  adjust: Readonly<Record<string, number>>,\n): readonly PresetGuide[] {\n  const seen = new Set<string>();\n  const merged: PresetGuide[] = avLst.map((guide) => {\n    const value = adjust[guide.name];\n    if (value === undefined) return guide;\n    seen.add(guide.name);\n    return { name: guide.name, fmla: ['val', String(Math.round(value))] };\n  });\n  for (const [name, value] of Object.entries(adjust)) {\n    if (seen.has(name)) continue;\n    merged.push({ name, fmla: ['val', String(Math.round(value))] });\n  }\n  return merged;\n}\n\n/**\n * Draw the overlay for one shape into a host `<svg>`, and make its handles drag.\n *\n * The host must be the same `<svg>` the slide is in, because the overlay is\n * emitted in slide coordinates and carries the shape's own transform - the same\n * arrangement `mountSlide` produces, so an editor appends this to that root.\n */\nexport function mountOverlay(\n  root: SVGSVGElement,\n  placed: Placed,\n  options: OverlayMountOptions = {},\n): MountedOverlay {\n  if (root === null || typeof root !== 'object' || typeof root.appendChild !== 'function') {\n    throw new RenderDomError(\n      'RENDER_DOM_NO_HOST',\n      'mountOverlay needs the slide <svg> to build in',\n    );\n  }\n  const document = options.document ?? root.ownerDocument;\n  if (document === null || document === undefined) {\n    throw new RenderDomError('RENDER_DOM_NO_DOCUMENT', 'the host element has no ownerDocument');\n  }\n\n  let current = placed;\n  let overlay = shapeOverlay(current, options);\n  let group = createNode(document, overlay.node) as SVGGElement;\n  root.appendChild(group);\n\n  let active: number | null = null;\n  let pointer: number | null = null;\n\n  function edit(at: Point, index: number): HandleEdit | null {\n    const source = current.geometrySource;\n    const handle = overlay.handles.find((h) => h.index === index);\n    if (source === null || handle === undefined) return null;\n    const local = inverseFramePoint(current.frame, at);\n    const adjust = dragHandle(\n      source.geometry,\n      { w: current.frame.cx, h: current.frame.cy },\n      handle.handle,\n      local,\n      { adjust: source.adjust },\n    );\n    if (Object.keys(adjust).length === 0) return null;\n    return { handle: index, adjust, avLst: mergeAdjust(source.adjust, adjust) };\n  }\n\n  /**\n   * Hold the pointer for the duration of the drag.\n   *\n   * On the root rather than on the handle, because the handle element is\n   * replaced on every update and a captured element that leaves the tree takes\n   * the capture with it - the drag would stop the moment the shape redrew.\n   *\n   * `setPointerCapture` throws `NotFoundError` for a pointer that is no longer\n   * active, which is reachable whenever the button is released between the\n   * event being queued and this running. Losing the capture degrades the drag\n   * to one that stops at the window edge; throwing would abandon it entirely.\n   */\n  function capture(pointerId: number): void {\n    try {\n      root.setPointerCapture(pointerId);\n    } catch {\n      // No capture, and the drag continues without it.\n    }\n  }\n\n  function onPointerDown(event: PointerEvent): void {\n    const target = event.target as Element | null;\n    const owner = target?.closest?.('[data-role=\"handle\"]');\n    const index = owner?.getAttribute('data-handle');\n    // A handle with no `gdRef` at all controls nothing and must not swallow\n    // the gesture. No preset has one - all 120 with an `a:ahLst` declare at\n    // least one axis - but an `a:custGeom` in a real file may.\n    if (index === null || index === undefined || owner?.getAttribute('data-axes') === '') return;\n    active = Number(index);\n    pointer = event.pointerId;\n    capture(event.pointerId);\n    event.preventDefault();\n  }\n\n  function onPointerMove(event: PointerEvent): void {\n    if (active === null || event.pointerId !== pointer) return;\n    const at = slidePoint(root, event.clientX, event.clientY);\n    if (at === null) return;\n    const result = edit(at, active);\n    if (result !== null) options.onChange?.(result);\n  }\n\n  function onPointerUp(event: PointerEvent): void {\n    if (active === null || event.pointerId !== pointer) return;\n    const at = slidePoint(root, event.clientX, event.clientY);\n    const result = at === null ? null : edit(at, active);\n    active = null;\n    pointer = null;\n    if (root.hasPointerCapture(event.pointerId)) root.releasePointerCapture(event.pointerId);\n    if (result !== null) options.onCommit?.(result);\n  }\n\n  // One signal for all four, so `unmount` cannot detach three of them and\n  // leave the fourth listening on a root that outlives this overlay. Four\n  // paired `removeEventListener` calls are four chances to forget one, and a\n  // half-removed listener is invisible until a second overlay is mounted on the\n  // same slide and the dead one starts editing a shape that is no longer there.\n  const listening = new AbortController();\n  const on = { signal: listening.signal };\n  root.addEventListener('pointerdown', onPointerDown, on);\n  root.addEventListener('pointermove', onPointerMove, on);\n  root.addEventListener('pointerup', onPointerUp, on);\n  root.addEventListener('pointercancel', onPointerUp, on);\n\n  return {\n    get root(): SVGGElement {\n      return group;\n    },\n    get overlay(): ShapeOverlay {\n      return overlay;\n    },\n    update(next: Placed): void {\n      current = next;\n      overlay = shapeOverlay(current, options);\n      const replacement = createNode(document, overlay.node) as SVGGElement;\n      group.replaceWith(replacement);\n      group = replacement;\n    },\n    dragging(): boolean {\n      return active !== null;\n    },\n    unmount(): void {\n      listening.abort();\n      group.remove();\n    },\n  };\n}\n","/**\n * The HTML text layer: the same lines as the SVG, as real text nodes.\n *\n * The plan's bet 4 asks for HTML text beside the SVG geometry, and the reason is\n * everything a `<text>` element cannot do: shaping, bidi, an IME, a selection a\n * user can drag, a screen reader. This draws from the identical `TextBlock`\n * `render-svg` emits, so the two cannot disagree about a line box - which is\n * sub-phase 3.8's own verification.\n *\n * ## Why the line carries an odd `line-height`\n *\n * A browser puts a baseline a half-leading plus an ascent below the line box and\n * PowerPoint puts it at the face's own share of it. `TextLine` carries the\n * `line-height` that reconciles the two, computed once in the layout pass. It\n * lands within one CSS pixel and no closer, because Chromium rounds a font's\n * ascent to a whole pixel before it lays a line out - which is why the SVG\n * emitter, where the baseline is a coordinate, is the one that thumbnails and\n * exports use.\n */\n\nimport type {\n  PieceRule,\n  TextBlock,\n  TextLine,\n  TextPiece,\n  UprightGlyph,\n} from '@pptx-studio/render-svg';\nimport { toCss, type Rgba } from '@pptx-studio/paint';\n\nimport { RenderDomError } from '../errors.js';\n\n/** A slide's size in points, which is what a block's coordinates are in. */\nexport interface LayerSize {\n  readonly widthPt: number;\n  readonly heightPt: number;\n}\n\n/** One shape's text, with the frame it is drawn in. */\nexport interface LayerBlock {\n  readonly block: TextBlock;\n  /** The shape's frame, in points on the slide. */\n  readonly leftPt: number;\n  readonly topPt: number;\n  readonly widthPt: number;\n  readonly heightPt: number;\n  /** `p:cNvPr/@id`, so a caller can find the element for a shape. */\n  readonly cNvPrId: number;\n  readonly name?: string | undefined;\n}\n\nexport interface TextLayerOptions {\n  readonly document?: Document | undefined;\n  /** CSS pixels per point. One transform, never a re-layout. */\n  readonly scale?: number | undefined;\n  /** Let the layer take pointer events. Off by default: the SVG hit-tests. */\n  readonly interactive?: boolean | undefined;\n}\n\nexport interface MountedTextLayer {\n  readonly root: HTMLElement;\n  /** The element holding one shape's text. */\n  element(cNvPrId: number): HTMLElement | null;\n  /** Rescale without re-laying anything out. */\n  resize(scale: number): void;\n  unmount(): void;\n}\n\nfunction px(value: number): string {\n  // Three decimals of a point is about a nanometre, and matches `render-svg`'s\n  // own rounding, so the two layers round identically.\n  return `${String(Math.round(value * 1000) / 1000)}px`;\n}\n\n/** Through `toCss`, because `Rgba` channels are 0..1 and not bytes. */\nfunction css(color: Rgba | null): string {\n  return color === null ? 'inherit' : toCss(color);\n}\n\n/** The dash pattern a rule is painted with, in multiples of its thickness. */\nconst DASHES: Readonly<Record<string, readonly number[]>> = {\n  dotted: [1, 2],\n  dashed: [4, 3],\n  longDashed: [8, 3],\n  dotDash: [4, 3, 1, 3],\n  dotDotDash: [1, 3, 1, 3, 4, 3],\n};\n\nfunction ruleElement(\n  document: Document,\n  rule: PieceRule,\n  x: number,\n  baseline: number,\n  color: string,\n): HTMLElement {\n  const el = document.createElement('div');\n  const style = el.style;\n  style.position = 'absolute';\n  style.left = px(x + rule.leftPt);\n  style.top = px(baseline + rule.topPt);\n  style.width = px(rule.widthPt);\n  style.height = px(rule.thickness);\n  const dash = DASHES[rule.pattern];\n  if (dash === undefined) {\n    style.background = color;\n    return el;\n  }\n  // A dashed rule as a repeating gradient, so it stays one element and scales\n  // with the layer instead of being redrawn.\n  const on = (dash[0] ?? 1) * rule.thickness;\n  const off = (dash[1] ?? 1) * rule.thickness;\n  style.background = `repeating-linear-gradient(to right, ${color} 0 ${px(on)}, transparent ${px(on)} ${px(on + off)})`;\n  return el;\n}\n\nfunction pieceElement(document: Document, piece: TextPiece): HTMLElement {\n  const el = document.createElement('span');\n  const style = el.style;\n  style.fontFamily = piece.cssFamily;\n  style.fontSize = px(piece.font.sz / 100);\n  if (piece.font.bold === true) style.fontWeight = 'bold';\n  if (piece.font.italic === true) style.fontStyle = 'italic';\n  if (piece.font.spc !== undefined && piece.font.spc !== 0) {\n    style.letterSpacing = px(piece.font.spc / 100);\n  }\n  style.color = css(piece.color);\n  if (piece.highlight !== null) style.background = css(piece.highlight);\n  if (piece.risePt !== 0) {\n    style.position = 'relative';\n    style.top = px(-piece.risePt);\n  }\n  el.textContent = piece.text;\n  return el;\n}\n\n/**\n * One glyph stood upright inside a turned line, placed from its own pen.\n *\n * The span is laid out unrotated with its baseline `sizePt` below its top - what\n * `UprightGlyph.strutPt` solves for - and then turned a quarter back about that\n * point, so the pen lands where the SVG emitter puts the same glyph.\n */\nfunction uprightElement(document: Document, piece: TextPiece, glyph: UprightGlyph): HTMLElement {\n  const el = pieceElement(document, piece);\n  const style = el.style;\n  const sizePt = piece.font.sz / 100;\n  style.position = 'absolute';\n  style.left = px(glyph.alongPt - piece.risePt);\n  style.top = px(glyph.acrossPt - sizePt);\n  style.lineHeight = px(glyph.strutPt);\n  style.transformOrigin = `0 ${px(sizePt)}`;\n  style.transform = 'rotate(-90deg)';\n  el.textContent = glyph.text;\n  return el;\n}\n\nfunction lineElement(document: Document, line: TextLine): HTMLElement {\n  const el = document.createElement('div');\n  const style = el.style;\n  style.position = 'absolute';\n  style.left = px(line.leftPt);\n  style.top = px(line.topPt);\n  style.width = px(line.widthPt);\n  style.height = px(line.heightPt);\n  style.lineHeight = px(line.strutPt);\n  style.whiteSpace = 'pre';\n  if (line.wordSpacingPt !== 0) style.wordSpacing = px(line.wordSpacingPt);\n\n  for (const piece of line.pieces) {\n    if (piece.upright.length > 0) {\n      for (const glyph of piece.upright) el.appendChild(uprightElement(document, piece, glyph));\n    } else el.appendChild(pieceElement(document, piece));\n  }\n\n  const baseline = line.baselinePt - line.topPt;\n  for (const piece of line.pieces) {\n    const color = css(piece.color);\n    for (const rule of piece.rules) {\n      el.appendChild(ruleElement(document, rule, piece.leftPt, baseline - piece.risePt, color));\n    }\n  }\n  return el;\n}\n\nfunction blockElement(document: Document, entry: LayerBlock): HTMLElement {\n  const el = document.createElement('div');\n  const style = el.style;\n  style.position = 'absolute';\n  style.left = px(entry.leftPt);\n  style.top = px(entry.topPt);\n  style.width = px(entry.widthPt);\n  style.height = px(entry.heightPt);\n  if (entry.block.turnDeg !== 0) {\n    style.transformOrigin = '50% 50%';\n    style.transform = `rotate(${String(entry.block.turnDeg)}deg)`;\n  }\n  el.setAttribute('data-text', String(entry.cNvPrId));\n  if (entry.name !== undefined && entry.name !== '') el.setAttribute('data-name', entry.name);\n  for (const line of entry.block.lines) el.appendChild(lineElement(document, line));\n  return el;\n}\n\n/**\n * Mount a text layer into a host, over a slide of `size` points.\n *\n * The host is emptied first. The layer is sized in points and scaled with one\n * transform, which is the plan's rule: font metrics are not linear in point\n * size, so a renderer that re-laid out per zoom would change its line breaks as\n * the user zoomed.\n */\nexport function mountTextLayer(\n  host: Element,\n  blocks: readonly LayerBlock[],\n  size: LayerSize,\n  options: TextLayerOptions = {},\n): MountedTextLayer {\n  if (host === null || typeof host !== 'object' || typeof host.appendChild !== 'function') {\n    throw new RenderDomError('RENDER_DOM_NO_HOST', 'mountTextLayer needs an element to build into');\n  }\n  const document = options.document ?? host.ownerDocument;\n  if (document === null || document === undefined) {\n    throw new RenderDomError('RENDER_DOM_NO_DOCUMENT', 'the host element has no ownerDocument');\n  }\n\n  const root = document.createElement('div');\n  const style = root.style;\n  style.position = 'absolute';\n  style.left = '0';\n  style.top = '0';\n  style.width = px(size.widthPt);\n  style.height = px(size.heightPt);\n  style.transformOrigin = '0 0';\n  style.pointerEvents = options.interactive === true ? 'auto' : 'none';\n  root.setAttribute('data-role', 'text-layer');\n\n  const byId = new Map<number, HTMLElement>();\n  for (const entry of blocks) {\n    if (entry.block.lines.length === 0) continue;\n    const el = blockElement(document, entry);\n    byId.set(entry.cNvPrId, el);\n    root.appendChild(el);\n  }\n\n  const apply = (scale: number): void => {\n    style.transform = scale === 1 ? '' : `scale(${String(scale)})`;\n  };\n  apply(options.scale ?? 1);\n  host.replaceChildren(root);\n\n  return {\n    root,\n    element(cNvPrId: number): HTMLElement | null {\n      return byId.get(cNvPrId) ?? null;\n    },\n    resize(scale: number): void {\n      apply(scale);\n    },\n    unmount(): void {\n      root.remove();\n    },\n  };\n}\n"],"mappings":";;;;AAeA,MAAa,yBAAwD,CACnE,sBACA,wBACF;AAEA,IAAa,iBAAb,cAAoC,MAAM;CACxC;CAEA,YAAY,MAA0B,SAAiB;EACrD,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,iBAAiB,OAAyC;CACxE,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACcA,MAAM,SAAS;;;;;;;;;;;;AAaf,SAAgB,WAAW,UAAoB,MAAqB;CAClE,IAAI,KAAK,SAAS,QAAQ,OAAO,SAAS,eAAe,KAAK,IAAI;CAClE,MAAM,KAAK,SAAS,gBAAgB,QAAQ,KAAK,GAAG;CACpD,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,KAAK,GAAG;EACtD,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW;EAC3C,GAAG,aAAa,MAAM,OAAO,UAAU,WAAW,IAAI,KAAK,IAAI,KAAK;CACtE;CACA,KAAK,MAAM,SAAS,KAAK,UAAU,GAAG,YAAY,WAAW,UAAU,KAAK,CAAC;CAC7E,OAAO;AACT;AAwBA,SAAS,cAAc,MAAe,SAAiC;CACrE,MAAM,WAAW,QAAQ,YAAY,KAAK;CAE1C,IAAI,aAAa,QAAQ,aAAa,KAAA,GACpC,MAAM,IAAI,eAAe,0BAA0B,uCAAuC;CAE5F,OAAO;AACT;;;;;;;;AASA,SAAgB,WACd,MACA,OACA,MACA,UAAwB,CAAC,GACX;CAGd,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,OAAO,KAAK,gBAAgB,YAC3E,MAAM,IAAI,eAAe,sBAAsB,2CAA2C;CAE5F,MAAM,WAAW,cAAc,MAAM,OAAO;CAC5C,MAAM,WAAW,UAAU,OAAO,MAAM,OAAO;CAC/C,MAAM,OAAO,WAAW,UAAU,SAAS,IAAI;CAE/C,KAAK,gBAAgB,IAAI;CAEzB,MAAM,uBAAO,IAAI,IAAwB;CACzC,MAAM,QAAQ,SAAwB;EACpC,MAAM,KAAK,KAAK,aAAa,YAAY;EACzC,IAAI,OAAO,QAAQ,CAAC,KAAK,IAAI,OAAO,EAAE,CAAC,GAAG,KAAK,IAAI,OAAO,EAAE,GAAG,IAAkB;EACjF,KAAK,MAAM,SAAS,MAAM,KAAK,KAAK,QAAQ,GAAG,KAAK,KAAK;CAC3D;CACA,KAAK,IAAI;CAET,OAAO;EACL;EACA,QAAQ,SAAS;EACjB,QAAQ,SAAoC;GAC1C,OAAO,KAAK,IAAI,OAAO,KAAK;EAC9B;EACA,OAAO,OAAe,QAAsB;GAC1C,KAAK,aAAa,SAAS,OAAO,KAAK,CAAC;GACxC,KAAK,aAAa,UAAU,OAAO,MAAM,CAAC;EAC5C;EACA,UAAgB;GACd,KAAK,OAAO;EACd;CACF;AACF;;;;;;;;AASA,SAAgB,kBACd,OACA,MACA,UAAyB,CAAC,GAClB;CACR,OAAO,aAAa,UAAU,OAAO,MAAM,OAAO,CAAC,CAAC,IAAI;AAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpFA,SAAgB,WAAW,MAAqB,SAAiB,SAA+B;CAC9F,MAAM,MAAM,KAAK,aAAa;CAC9B,IAAI,QAAQ,MAAM,OAAO;CACzB,MAAM,QAAQ,KAAK,eAAe;CAClC,MAAM,IAAI;CACV,MAAM,IAAI;CACV,MAAM,QAAQ,MAAM,gBAAgB,IAAI,QAAQ,CAAC;CACjD,OAAO;EAAE,GAAG,MAAM;EAAG,GAAG,MAAM;CAAE;AAClC;;;;;;;;;;AAWA,SAAgB,YACd,OACA,QACwB;CACxB,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAAwB,MAAM,KAAK,UAAU;EACjD,MAAM,QAAQ,OAAO,MAAM;EAC3B,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,KAAK,IAAI,MAAM,IAAI;EACnB,OAAO;GAAE,MAAM,MAAM;GAAM,MAAM,CAAC,OAAO,OAAO,KAAK,MAAM,KAAK,CAAC,CAAC;EAAE;CACtE,CAAC;CACD,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,GAAG;EAClD,IAAI,KAAK,IAAI,IAAI,GAAG;EACpB,OAAO,KAAK;GAAE;GAAM,MAAM,CAAC,OAAO,OAAO,KAAK,MAAM,KAAK,CAAC,CAAC;EAAE,CAAC;CAChE;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,aACd,MACA,QACA,UAA+B,CAAC,GAChB;CAChB,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,OAAO,KAAK,gBAAgB,YAC3E,MAAM,IAAI,eACR,sBACA,gDACF;CAEF,MAAM,WAAW,QAAQ,YAAY,KAAK;CAC1C,IAAI,aAAa,QAAQ,aAAa,KAAA,GACpC,MAAM,IAAI,eAAe,0BAA0B,uCAAuC;CAG5F,IAAI,UAAU;CACd,IAAI,UAAU,aAAa,SAAS,OAAO;CAC3C,IAAI,QAAQ,WAAW,UAAU,QAAQ,IAAI;CAC7C,KAAK,YAAY,KAAK;CAEtB,IAAI,SAAwB;CAC5B,IAAI,UAAyB;CAE7B,SAAS,KAAK,IAAW,OAAkC;EACzD,MAAM,SAAS,QAAQ;EACvB,MAAM,SAAS,QAAQ,QAAQ,MAAM,MAAM,EAAE,UAAU,KAAK;EAC5D,IAAI,WAAW,QAAQ,WAAW,KAAA,GAAW,OAAO;EACpD,MAAM,QAAQ,kBAAkB,QAAQ,OAAO,EAAE;EACjD,MAAM,SAAS,WACb,OAAO,UACP;GAAE,GAAG,QAAQ,MAAM;GAAI,GAAG,QAAQ,MAAM;EAAG,GAC3C,OAAO,QACP,OACA,EAAE,QAAQ,OAAO,OAAO,CAC1B;EACA,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW,GAAG,OAAO;EAC7C,OAAO;GAAE,QAAQ;GAAO;GAAQ,OAAO,YAAY,OAAO,QAAQ,MAAM;EAAE;CAC5E;;;;;;;;;;;;;CAcA,SAAS,QAAQ,WAAyB;EACxC,IAAI;GACF,KAAK,kBAAkB,SAAS;EAClC,QAAQ,CAER;CACF;CAEA,SAAS,cAAc,OAA2B;EAEhD,MAAM,QADS,MAAM,QACC,UAAU,wBAAsB;EACtD,MAAM,QAAQ,OAAO,aAAa,aAAa;EAI/C,IAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,OAAO,aAAa,WAAW,MAAM,IAAI;EACtF,SAAS,OAAO,KAAK;EACrB,UAAU,MAAM;EAChB,QAAQ,MAAM,SAAS;EACvB,MAAM,eAAe;CACvB;CAEA,SAAS,cAAc,OAA2B;EAChD,IAAI,WAAW,QAAQ,MAAM,cAAc,SAAS;EACpD,MAAM,KAAK,WAAW,MAAM,MAAM,SAAS,MAAM,OAAO;EACxD,IAAI,OAAO,MAAM;EACjB,MAAM,SAAS,KAAK,IAAI,MAAM;EAC9B,IAAI,WAAW,MAAM,QAAQ,WAAW,MAAM;CAChD;CAEA,SAAS,YAAY,OAA2B;EAC9C,IAAI,WAAW,QAAQ,MAAM,cAAc,SAAS;EACpD,MAAM,KAAK,WAAW,MAAM,MAAM,SAAS,MAAM,OAAO;EACxD,MAAM,SAAS,OAAO,OAAO,OAAO,KAAK,IAAI,MAAM;EACnD,SAAS;EACT,UAAU;EACV,IAAI,KAAK,kBAAkB,MAAM,SAAS,GAAG,KAAK,sBAAsB,MAAM,SAAS;EACvF,IAAI,WAAW,MAAM,QAAQ,WAAW,MAAM;CAChD;CAOA,MAAM,YAAY,IAAI,gBAAgB;CACtC,MAAM,KAAK,EAAE,QAAQ,UAAU,OAAO;CACtC,KAAK,iBAAiB,eAAe,eAAe,EAAE;CACtD,KAAK,iBAAiB,eAAe,eAAe,EAAE;CACtD,KAAK,iBAAiB,aAAa,aAAa,EAAE;CAClD,KAAK,iBAAiB,iBAAiB,aAAa,EAAE;CAEtD,OAAO;EACL,IAAI,OAAoB;GACtB,OAAO;EACT;EACA,IAAI,UAAwB;GAC1B,OAAO;EACT;EACA,OAAO,MAAoB;GACzB,UAAU;GACV,UAAU,aAAa,SAAS,OAAO;GACvC,MAAM,cAAc,WAAW,UAAU,QAAQ,IAAI;GACrD,MAAM,YAAY,WAAW;GAC7B,QAAQ;EACV;EACA,WAAoB;GAClB,OAAO,WAAW;EACpB;EACA,UAAgB;GACd,UAAU,MAAM;GAChB,MAAM,OAAO;EACf;CACF;AACF;;;ACrLA,SAAS,GAAG,OAAuB;CAGjC,OAAO,GAAG,OAAO,KAAK,MAAM,QAAQ,GAAI,IAAI,GAAI,EAAE;AACpD;;AAGA,SAAS,IAAI,OAA4B;CACvC,OAAO,UAAU,OAAO,YAAY,MAAM,KAAK;AACjD;;AAGA,MAAM,SAAsD;CAC1D,QAAQ,CAAC,GAAG,CAAC;CACb,QAAQ,CAAC,GAAG,CAAC;CACb,YAAY,CAAC,GAAG,CAAC;CACjB,SAAS;EAAC;EAAG;EAAG;EAAG;CAAC;CACpB,YAAY;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;AAC/B;AAEA,SAAS,YACP,UACA,MACA,GACA,UACA,OACa;CACb,MAAM,KAAK,SAAS,cAAc,KAAK;CACvC,MAAM,QAAQ,GAAG;CACjB,MAAM,WAAW;CACjB,MAAM,OAAO,GAAG,IAAI,KAAK,MAAM;CAC/B,MAAM,MAAM,GAAG,WAAW,KAAK,KAAK;CACpC,MAAM,QAAQ,GAAG,KAAK,OAAO;CAC7B,MAAM,SAAS,GAAG,KAAK,SAAS;CAChC,MAAM,OAAO,OAAO,KAAK;CACzB,IAAI,SAAS,KAAA,GAAW;EACtB,MAAM,aAAa;EACnB,OAAO;CACT;CAGA,MAAM,MAAM,KAAK,MAAM,KAAK,KAAK;CACjC,MAAM,OAAO,KAAK,MAAM,KAAK,KAAK;CAClC,MAAM,aAAa,uCAAuC,MAAM,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,EAAE,EAAE,GAAG,GAAG,KAAK,GAAG,EAAE;CACnH,OAAO;AACT;AAEA,SAAS,aAAa,UAAoB,OAA+B;CACvE,MAAM,KAAK,SAAS,cAAc,MAAM;CACxC,MAAM,QAAQ,GAAG;CACjB,MAAM,aAAa,MAAM;CACzB,MAAM,WAAW,GAAG,MAAM,KAAK,KAAK,GAAG;CACvC,IAAI,MAAM,KAAK,SAAS,MAAM,MAAM,aAAa;CACjD,IAAI,MAAM,KAAK,WAAW,MAAM,MAAM,YAAY;CAClD,IAAI,MAAM,KAAK,QAAQ,KAAA,KAAa,MAAM,KAAK,QAAQ,GACrD,MAAM,gBAAgB,GAAG,MAAM,KAAK,MAAM,GAAG;CAE/C,MAAM,QAAQ,IAAI,MAAM,KAAK;CAC7B,IAAI,MAAM,cAAc,MAAM,MAAM,aAAa,IAAI,MAAM,SAAS;CACpE,IAAI,MAAM,WAAW,GAAG;EACtB,MAAM,WAAW;EACjB,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM;CAC9B;CACA,GAAG,cAAc,MAAM;CACvB,OAAO;AACT;;;;;;;;AASA,SAAS,eAAe,UAAoB,OAAkB,OAAkC;CAC9F,MAAM,KAAK,aAAa,UAAU,KAAK;CACvC,MAAM,QAAQ,GAAG;CACjB,MAAM,SAAS,MAAM,KAAK,KAAK;CAC/B,MAAM,WAAW;CACjB,MAAM,OAAO,GAAG,MAAM,UAAU,MAAM,MAAM;CAC5C,MAAM,MAAM,GAAG,MAAM,WAAW,MAAM;CACtC,MAAM,aAAa,GAAG,MAAM,OAAO;CACnC,MAAM,kBAAkB,KAAK,GAAG,MAAM;CACtC,MAAM,YAAY;CAClB,GAAG,cAAc,MAAM;CACvB,OAAO;AACT;AAEA,SAAS,YAAY,UAAoB,MAA6B;CACpE,MAAM,KAAK,SAAS,cAAc,KAAK;CACvC,MAAM,QAAQ,GAAG;CACjB,MAAM,WAAW;CACjB,MAAM,OAAO,GAAG,KAAK,MAAM;CAC3B,MAAM,MAAM,GAAG,KAAK,KAAK;CACzB,MAAM,QAAQ,GAAG,KAAK,OAAO;CAC7B,MAAM,SAAS,GAAG,KAAK,QAAQ;CAC/B,MAAM,aAAa,GAAG,KAAK,OAAO;CAClC,MAAM,aAAa;CACnB,IAAI,KAAK,kBAAkB,GAAG,MAAM,cAAc,GAAG,KAAK,aAAa;CAEvE,KAAK,MAAM,SAAS,KAAK,QACvB,IAAI,MAAM,QAAQ,SAAS,GACzB,KAAK,MAAM,SAAS,MAAM,SAAS,GAAG,YAAY,eAAe,UAAU,OAAO,KAAK,CAAC;MACnF,GAAG,YAAY,aAAa,UAAU,KAAK,CAAC;CAGrD,MAAM,WAAW,KAAK,aAAa,KAAK;CACxC,KAAK,MAAM,SAAS,KAAK,QAAQ;EAC/B,MAAM,QAAQ,IAAI,MAAM,KAAK;EAC7B,KAAK,MAAM,QAAQ,MAAM,OACvB,GAAG,YAAY,YAAY,UAAU,MAAM,MAAM,QAAQ,WAAW,MAAM,QAAQ,KAAK,CAAC;CAE5F;CACA,OAAO;AACT;AAEA,SAAS,aAAa,UAAoB,OAAgC;CACxE,MAAM,KAAK,SAAS,cAAc,KAAK;CACvC,MAAM,QAAQ,GAAG;CACjB,MAAM,WAAW;CACjB,MAAM,OAAO,GAAG,MAAM,MAAM;CAC5B,MAAM,MAAM,GAAG,MAAM,KAAK;CAC1B,MAAM,QAAQ,GAAG,MAAM,OAAO;CAC9B,MAAM,SAAS,GAAG,MAAM,QAAQ;CAChC,IAAI,MAAM,MAAM,YAAY,GAAG;EAC7B,MAAM,kBAAkB;EACxB,MAAM,YAAY,UAAU,OAAO,MAAM,MAAM,OAAO,EAAE;CAC1D;CACA,GAAG,aAAa,aAAa,OAAO,MAAM,OAAO,CAAC;CAClD,IAAI,MAAM,SAAS,KAAA,KAAa,MAAM,SAAS,IAAI,GAAG,aAAa,aAAa,MAAM,IAAI;CAC1F,KAAK,MAAM,QAAQ,MAAM,MAAM,OAAO,GAAG,YAAY,YAAY,UAAU,IAAI,CAAC;CAChF,OAAO;AACT;;;;;;;;;AAUA,SAAgB,eACd,MACA,QACA,MACA,UAA4B,CAAC,GACX;CAClB,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,OAAO,KAAK,gBAAgB,YAC3E,MAAM,IAAI,eAAe,sBAAsB,+CAA+C;CAEhG,MAAM,WAAW,QAAQ,YAAY,KAAK;CAC1C,IAAI,aAAa,QAAQ,aAAa,KAAA,GACpC,MAAM,IAAI,eAAe,0BAA0B,uCAAuC;CAG5F,MAAM,OAAO,SAAS,cAAc,KAAK;CACzC,MAAM,QAAQ,KAAK;CACnB,MAAM,WAAW;CACjB,MAAM,OAAO;CACb,MAAM,MAAM;CACZ,MAAM,QAAQ,GAAG,KAAK,OAAO;CAC7B,MAAM,SAAS,GAAG,KAAK,QAAQ;CAC/B,MAAM,kBAAkB;CACxB,MAAM,gBAAgB,QAAQ,gBAAgB,OAAO,SAAS;CAC9D,KAAK,aAAa,aAAa,YAAY;CAE3C,MAAM,uBAAO,IAAI,IAAyB;CAC1C,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,MAAM,MAAM,MAAM,WAAW,GAAG;EACpC,MAAM,KAAK,aAAa,UAAU,KAAK;EACvC,KAAK,IAAI,MAAM,SAAS,EAAE;EAC1B,KAAK,YAAY,EAAE;CACrB;CAEA,MAAM,SAAS,UAAwB;EACrC,MAAM,YAAY,UAAU,IAAI,KAAK,SAAS,OAAO,KAAK,EAAE;CAC9D;CACA,MAAM,QAAQ,SAAS,CAAC;CACxB,KAAK,gBAAgB,IAAI;CAEzB,OAAO;EACL;EACA,QAAQ,SAAqC;GAC3C,OAAO,KAAK,IAAI,OAAO,KAAK;EAC9B;EACA,OAAO,OAAqB;GAC1B,MAAM,KAAK;EACb;EACA,UAAgB;GACd,KAAK,OAAO;EACd;CACF;AACF"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@pptx-studio/render-dom",
+  "version": "0.0.0",
+  "description": "The live DOM renderer: one element per shape, over the same layout engine as render-svg",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dewiride-Open-Source/Dewiride-PPTX-Studio.git",
+    "directory": "packages/render-dom"
+  },
+  "homepage": "https://github.com/Dewiride-Open-Source/Dewiride-PPTX-Studio/tree/main/packages/render-dom#readme",
+  "bugs": "https://github.com/Dewiride-Open-Source/Dewiride-PPTX-Studio/issues",
+  "keywords": [
+    "ooxml",
+    "pptx",
+    "powerpoint",
+    "renderer",
+    "dom",
+    "svg"
+  ],
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "pkg:qa": "publint --strict && attw --pack . --profile esm-only"
+  },
+  "dependencies": {
+    "@pptx-studio/geometry": "workspace:^",
+    "@pptx-studio/model": "workspace:^",
+    "@pptx-studio/paint": "workspace:^",
+    "@pptx-studio/render-svg": "workspace:^"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "catalog:",
+    "publint": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:"
+  }
+}