@vectojs/core 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -3,14 +3,16 @@ import {
   LayoutResultBuffer,
   computeLineSegments,
   createCanvasMeasurer
-} from "./chunk-T456DL4P.mjs";
+} from "./chunk-LIOJ37MH.mjs";
 import {
   CanvasRenderer,
   SVGRenderer,
   WebGPUParticleSystemManager,
   createWebGLPointRenderer,
-  parseColorToRGBA
-} from "./chunk-2Y45S4JK.mjs";
+  isSafeUrl,
+  parseColorToRGBA,
+  sanitizeUrl
+} from "./chunk-NKOQV3RM.mjs";
 import {
   Easing,
   Entity,
@@ -22,12 +24,12 @@ import {
   TweenDriver,
   VectoJSEvent,
   isTweenConfig
-} from "./chunk-H3QIE77O.mjs";
+} from "./chunk-ISGOYXPF.mjs";
 import {
   ArabicShaper,
   BidiResolver,
   LayoutWorkerManager
-} from "./chunk-YA2J5ZH7.mjs";
+} from "./chunk-YSS44ADQ.mjs";
 
 // src/tree/ComputeParticleEntity.ts
 var PARTICLE_STRIDE_FLOATS = 8;
@@ -489,6 +491,17 @@ var Scene = class _Scene {
   getRenderer() {
     return this.renderer;
   }
+  /** Convert browser viewport coordinates into this Scene's logical coordinates. */
+  clientToScene(clientX, clientY) {
+    const rect = this.canvas.getBoundingClientRect?.();
+    if (!rect) return { x: clientX, y: clientY };
+    const cssWidth = rect.width || this.canvas.clientWidth || this.width;
+    const cssHeight = rect.height || this.canvas.clientHeight || this.height;
+    return {
+      x: (clientX - rect.left) * (cssWidth > 0 ? this.width / cssWidth : 1),
+      y: (clientY - rect.top) * (cssHeight > 0 ? this.height / cssHeight : 1)
+    };
+  }
   /**
    * Add a top-level entity to the scene graph.
    *
@@ -563,12 +576,21 @@ var Scene = class _Scene {
     this.removeA11yRecursively(overlay);
     this.markDirty();
   }
+  destroyEntitySubtree(entity) {
+    while (entity.children.length > 0) this.destroyEntitySubtree(entity.children.at(-1));
+    entity.destroy();
+  }
   /**
    * Tear down the Scene, halt the loop, and clean up event listeners and DOM elements.
    */
   destroy() {
+    if (this.destroyed) return;
     this.destroyed = true;
     this.stop();
+    while (this.root.children.length > 0) this.destroyEntitySubtree(this.root.children.at(-1));
+    while (this.overlayRoot.children.length > 0) {
+      this.destroyEntitySubtree(this.overlayRoot.children.at(-1));
+    }
     if (typeof window !== "undefined" && !this.disableWindowResize) {
       window.removeEventListener("resize", this.resizeHandler);
     }
@@ -584,6 +606,7 @@ var Scene = class _Scene {
     this.portalRoot?.remove();
     this.a11yElements.clear();
     this.pointRenderer?.destroy();
+    this.renderer.dispose?.();
     this.glCanvas?.remove();
     this.gpuCanvas?.remove();
     this.gpuCanvas = null;
@@ -603,9 +626,9 @@ var Scene = class _Scene {
     }
     if (typeof window !== "undefined" && this.canvas && typeof this.canvas.addEventListener === "function") {
       this.pointerMoveListener = (e) => {
-        const rect = this.canvas.getBoundingClientRect();
-        this.mouseX = e.clientX - rect.left;
-        this.mouseY = e.clientY - rect.top;
+        const point = this.clientToScene(e.clientX, e.clientY);
+        this.mouseX = point.x;
+        this.mouseY = point.y;
       };
       this.pointerLeaveListener = () => {
         this.mouseX = -9999;
@@ -656,6 +679,17 @@ var Scene = class _Scene {
       this.caretBlinkTimer = null;
     }
   }
+  /**
+   * Manually advance the scene clock by `dt` milliseconds and render synchronously.
+   * Essential for deterministic rendering (e.g. video export).
+   * Note: You should call `scene.stop()` before using this to avoid conflict with the rAF loop.
+   */
+  step(dt) {
+    const time = this.lastTime + dt;
+    this.lastTime = time;
+    this.render(this.renderer, dt, time);
+    this.dirty = false;
+  }
   /**
    * Mark the scene as needing a redraw on the next frame.
    *
@@ -710,6 +744,7 @@ var Scene = class _Scene {
         el.id = node.id;
         el.setAttribute("data-vecto-id", node.id);
         el.style.position = "absolute";
+        el.style.transformOrigin = "0 0";
         el.style.pointerEvents = "auto";
         el.style.touchAction = "pinch-zoom";
         el.style.margin = "0";
@@ -857,7 +892,8 @@ var Scene = class _Scene {
         if (el.placeholder !== attrs.placeholder) el.placeholder = attrs.placeholder;
       }
       if (attrs.href !== void 0 && el instanceof HTMLAnchorElement) {
-        if (el.getAttribute("href") !== attrs.href) el.setAttribute("href", attrs.href);
+        const safeHref = sanitizeUrl(attrs.href);
+        if (el.getAttribute("href") !== safeHref) el.setAttribute("href", safeHref);
       }
       if (el instanceof HTMLImageElement) {
         if (attrs.src !== void 0 && el.src !== attrs.src) el.src = attrs.src;
@@ -918,12 +954,12 @@ var Scene = class _Scene {
         el.style.height = `${this.height}px`;
         el.style.transform = "";
       } else {
-        const pos = node.getGlobalPosition();
-        el.style.left = `${pos.x + node.a11yOffsetX}px`;
-        el.style.top = `${pos.y + node.a11yOffsetY}px`;
-        el.style.width = `${node.width * node.scaleX}px`;
-        el.style.height = `${node.height * node.scaleY}px`;
-        el.style.transform = `rotate(${node.rotation}rad)`;
+        const { a, b, c, d, e, f } = node.getWorldTransform();
+        el.style.left = `${e + node.a11yOffsetX}px`;
+        el.style.top = `${f + node.a11yOffsetY}px`;
+        el.style.width = `${node.width}px`;
+        el.style.height = `${node.height}px`;
+        el.style.transform = `matrix(${a}, ${b}, ${c}, ${d}, 0, 0)`;
       }
     }
     for (const child of node.children) this.syncA11y(child);
@@ -985,6 +1021,35 @@ var Scene = class _Scene {
     }
     this.a11yNeedsReorder = false;
   }
+  /** Keep DOM/WebGL overlay layers aligned with the canvas's CSS box. */
+  syncOverlayGeometry() {
+    const parent = this.canvas.parentElement;
+    if (!parent) return;
+    const canvasRect = this.canvas.getBoundingClientRect?.();
+    const parentRect = parent.getBoundingClientRect?.();
+    const cssWidth = canvasRect?.width || this.canvas.clientWidth || this.width;
+    const cssHeight = canvasRect?.height || this.canvas.clientHeight || this.height;
+    const left = (canvasRect?.left ?? 0) - (parentRect?.left ?? 0) - (parent.clientLeft || 0) + parent.scrollLeft;
+    const top = (canvasRect?.top ?? 0) - (parentRect?.top ?? 0) - (parent.clientTop || 0) + parent.scrollTop;
+    const scaleX = this.width > 0 ? cssWidth / this.width : 1;
+    const scaleY = this.height > 0 ? cssHeight / this.height : 1;
+    for (const root of [this.a11yRoot, this.portalRoot]) {
+      if (!root) continue;
+      root.style.left = `${left}px`;
+      root.style.top = `${top}px`;
+      root.style.width = `${this.width}px`;
+      root.style.height = `${this.height}px`;
+      root.style.transformOrigin = "0 0";
+      root.style.transform = `scale(${scaleX}, ${scaleY})`;
+    }
+    for (const canvas of [this.glCanvas, this.gpuCanvas]) {
+      if (!canvas) continue;
+      canvas.style.left = `${left}px`;
+      canvas.style.top = `${top}px`;
+      canvas.style.width = `${cssWidth}px`;
+      canvas.style.height = `${cssHeight}px`;
+    }
+  }
   getA11yTree() {
     const map = /* @__PURE__ */ new Map();
     const roots = [];
@@ -1028,7 +1093,7 @@ var Scene = class _Scene {
     traverse(this.root, null);
     return roots;
   }
-  renderPortalDOM(portal, te, tf, a, b, c, d) {
+  renderPortalDOM(portal, te, tf, a, b, c, d, opacity) {
     if (!this.portalRoot) return;
     this.activePortalsThisFrame.add(portal.id);
     this.portalEntities.set(portal.id, portal);
@@ -1062,6 +1127,11 @@ var Scene = class _Scene {
       portal.domElement.style.zIndex = zIndexStr;
       portal.lastZIndex = zIndexStr;
     }
+    const opacityStr = String(opacity);
+    if (portal.lastOpacity !== opacityStr) {
+      portal.domElement.style.opacity = opacityStr;
+      portal.lastOpacity = opacityStr;
+    }
   }
   reconcilePortals() {
     if (!this.portalRoot) return;
@@ -1109,19 +1179,17 @@ var Scene = class _Scene {
     }
     this.render(this.renderer, dt, time);
     const hasActiveAnimation = this.hasAnyPendingAnimation(this.root) || this.hasAnyPendingAnimation(this.overlayRoot);
-    if (hasActiveAnimation) {
+    const hasInteractive = this.hasAnyInteractive(this.root) || this.hasAnyInteractive(this.overlayRoot);
+    const shouldSyncInterval = this.a11ySyncInterval <= 0 || time - this.lastA11ySync >= this.a11ySyncInterval;
+    if ((hasInteractive || this.a11yElements.size > 0) && (shouldSyncInterval || this.a11yPendingSyncAfterAnimation)) {
+      this.lastA11ySync = time;
+      if (hasInteractive) {
+        this.syncA11y(this.root);
+      }
+      this.enforceA11yDomOrder();
+      this.a11yPendingSyncAfterAnimation = hasActiveAnimation;
+    } else if (hasActiveAnimation) {
       this.a11yPendingSyncAfterAnimation = true;
-    } else {
-      const hasInteractive = this.hasAnyInteractive(this.root) || this.hasAnyInteractive(this.overlayRoot);
-      const shouldSyncInterval = this.a11ySyncInterval <= 0 || time - this.lastA11ySync >= this.a11ySyncInterval;
-      if ((hasInteractive || this.a11yElements.size > 0) && (shouldSyncInterval || this.a11yPendingSyncAfterAnimation)) {
-        this.lastA11ySync = time;
-        if (hasInteractive) {
-          this.syncA11y(this.root);
-        }
-        this.enforceA11yDomOrder();
-        this.a11yPendingSyncAfterAnimation = false;
-      }
     }
     this.dirty = false;
     this.scheduleFrame();
@@ -1134,14 +1202,18 @@ var Scene = class _Scene {
    * @param time - Current absolute time in milliseconds (default 0).
    */
   render(renderer, dt = 0, time = 0) {
-    if (this.a11yRoot && this.canvas.parentElement) {
+    const isMainRenderer = renderer === this.renderer;
+    if (isMainRenderer && this.a11yRoot && this.canvas.parentElement) {
       const parentStyle = this.canvas.parentElement.style;
       if (!parentStyle.position || parentStyle.position === "static") {
         parentStyle.position = "relative";
       }
+      this.syncOverlayGeometry();
+    }
+    if (isMainRenderer) {
+      this.renderOrderCounter = 0;
+      this.activePortalsThisFrame.clear();
     }
-    this.renderOrderCounter = 0;
-    this.activePortalsThisFrame.clear();
     const computeEntities = [];
     const collectComputeEntities = (node) => {
       if (node instanceof ComputeParticleEntity) {
@@ -1156,7 +1228,8 @@ var Scene = class _Scene {
       collectComputeEntities(overlay);
     }
     if (computeEntities.length > 0) {
-      if (!this.device && !this.webgpuDisabled && !this.initializingWebGPU && !this.deviceLost) {
+      const isMainRenderPath = renderer === this.renderer;
+      if (isMainRenderPath && !this.device && !this.webgpuDisabled && !this.initializingWebGPU && !this.deviceLost) {
         this.initializingWebGPU = true;
         this.initWebGPUContext(computeEntities).then((newDevice) => {
           this.device = newDevice;
@@ -1179,12 +1252,16 @@ var Scene = class _Scene {
             }
           }
         }).catch((err) => {
-          console.error("Failed to initialize WebGPU:", err);
+          if (this.particleBackend === "webgpu") {
+            console.error("Failed to initialize WebGPU:", err);
+          } else {
+            console.warn("WebGPU unavailable; using CPU particle fallback.", err);
+          }
           this.webgpuDisabled = true;
           this.initializingWebGPU = false;
         });
       }
-      if (this.device && this.manager && !this.deviceLost && !this.webgpuDisabled) {
+      if (isMainRenderPath && this.device && this.manager && !this.deviceLost && !this.webgpuDisabled) {
         try {
           const commandEncoder = this.device.createCommandEncoder();
           const computePass = commandEncoder.beginComputePass();
@@ -1232,21 +1309,20 @@ var Scene = class _Scene {
           this.device = null;
           this.recreateWebGPUDeviceWithRetry(computeEntities);
         }
-      } else {
+      } else if (isMainRenderPath) {
         for (const entity of computeEntities) {
           entity.updateCPU(dt / 1e3, this.mouseX, this.mouseY, this.width, this.height);
         }
       }
     }
     renderer.clear();
-    const isMainRenderer = renderer === this.renderer;
     if (isMainRenderer) {
       this.pointRenderer?.begin();
     }
     const vw = this.width;
     const vh = this.height;
-    const renderNode = (node, pa, pb, pc, pd, pe, pf) => {
-      node.update(dt, time);
+    const renderNode = (node, pa, pb, pc, pd, pe, pf, parentOpacity) => {
+      if (isMainRenderer) node.update(dt, time);
       const cos = Math.cos(node.rotation);
       const sin = Math.sin(node.rotation);
       const te = pa * node.x + pc * node.y + pe;
@@ -1255,16 +1331,24 @@ var Scene = class _Scene {
       const sxSin = node.scaleX * sin;
       const syCos = node.scaleY * cos;
       const sySin = node.scaleY * sin;
-      const a = pa * sxCos + pc * sxSin;
-      const b = pb * sxCos + pd * sxSin;
-      const c = pa * -sySin + pc * syCos;
-      const d = pb * -sySin + pd * syCos;
-      const a11yEl = this.a11yElements.get(node.id);
+      const a = pa * sxCos + pc * sySin;
+      const b = pb * sxCos + pd * sySin;
+      const c = pa * -sxSin + pc * syCos;
+      const d = pb * -sxSin + pd * syCos;
+      const worldScaleX = Math.hypot(a, b);
+      const worldScaleY = Math.hypot(c, d);
+      const worldOpacity = parentOpacity * node.opacity;
+      const scaleTolerance = Math.max(1, worldScaleX, worldScaleY) * 1e-6;
+      const orthogonalTolerance = Math.max(1, worldScaleX * worldScaleY) * 1e-6;
+      const isSimilarityTransform = Number.isFinite(worldScaleX) && Number.isFinite(worldScaleY) && Math.abs(worldScaleX - worldScaleY) <= scaleTolerance && Math.abs(a * c + b * d) <= orthogonalTolerance;
+      const a11yEl = isMainRenderer ? this.a11yElements.get(node.id) : void 0;
       if (a11yEl) {
         a11yEl.style.zIndex = String(this.renderOrderCounter++);
       }
       if (node.isDOMPortal) {
-        this.renderPortalDOM(node, te, tf, a, b, c, d);
+        if (isMainRenderer) {
+          this.renderPortalDOM(node, te, tf, a, b, c, d, worldOpacity);
+        }
         return;
       }
       let visible = true;
@@ -1290,33 +1374,27 @@ var Scene = class _Scene {
       if (node.children.length === 0 && node.scaleX === node.scaleY) {
         const bc = node.getBatchCircle();
         if (bc) {
-          if (visible) {
-            if (isMainRenderer && this.pointRenderer) {
-              this.pointRenderer.addCircle(
-                te,
-                tf,
-                bc.radius * Math.hypot(a, b),
-                bc.color,
-                node.opacity
-              );
-            } else {
-              renderer.fillCircle(node.x, node.y, bc.radius * node.scaleX, bc.color, node.opacity);
+          if (!visible) return;
+          if (isMainRenderer && this.pointRenderer) {
+            if (isSimilarityTransform) {
+              this.pointRenderer.addCircle(te, tf, bc.radius * worldScaleX, bc.color, worldOpacity);
+              return;
             }
+          } else {
+            renderer.fillCircle(node.x, node.y, bc.radius * node.scaleX, bc.color, worldOpacity);
+            return;
           }
-          return;
-        }
-        if (isMainRenderer && this.pointRenderer) {
+        } else if (isMainRenderer && this.pointRenderer) {
           const br = node.getBatchRect();
-          if (br) {
+          if (br && isSimilarityTransform && a * d - b * c >= 0) {
             if (visible) {
-              const ws = Math.hypot(a, b);
               this.pointRenderer.addRect(
                 te,
                 tf,
-                br.width * ws,
-                br.height * ws,
+                br.width * worldScaleX,
+                br.height * worldScaleX,
                 br.color,
-                node.opacity,
+                worldOpacity,
                 Math.atan2(b, a)
               );
             }
@@ -1329,11 +1407,11 @@ var Scene = class _Scene {
       renderer.translate(node.x, node.y);
       renderer.scale(node.scaleX, node.scaleY);
       renderer.rotate(node.rotation);
-      renderer.setGlobalAlpha(node.opacity);
+      renderer.setGlobalAlpha(worldOpacity);
       if (visible) {
         if (node instanceof ComputeParticleEntity) {
           if (this.deviceLost || this.webgpuDisabled || !this.device || !this.manager) {
-            this.renderCPUParticles(renderer, node);
+            this.renderCPUParticles(renderer, node, worldOpacity);
           }
         } else {
           node.render(renderer);
@@ -1343,16 +1421,16 @@ var Scene = class _Scene {
         renderer.clip(0, 0, node.width, node.height);
       }
       for (const child of node.children) {
-        renderNode(child, a, b, c, d, te, tf);
+        renderNode(child, a, b, c, d, te, tf, worldOpacity);
       }
       renderer.flush();
       renderer.restore();
     };
-    renderNode(this.root, 1, 0, 0, 1, 0, 0);
+    renderNode(this.root, 1, 0, 0, 1, 0, 0, 1);
     for (const overlay of this.overlayRoot.children) {
-      renderNode(overlay, 1, 0, 0, 1, 0, 0);
+      renderNode(overlay, 1, 0, 0, 1, 0, 0, 1);
     }
-    this.reconcilePortals();
+    if (isMainRenderer) this.reconcilePortals();
     renderer.flush();
     if (isMainRenderer) {
       this.pointRenderer?.flush();
@@ -1482,13 +1560,15 @@ var Scene = class _Scene {
           this.manager.initPipelines(format);
           for (const entity of entities) {
             this.manager.setupEntityResources(entity);
-            newDevice.queue.writeBuffer(entity.gpuStorageBuffer, 0, entity.particleData);
+            if (entity.gpuStorageBuffer) {
+              newDevice.queue.writeBuffer(entity.gpuStorageBuffer, 0, entity.particleData);
+            }
           }
         }
       }).catch(() => this.recreateWebGPUDeviceWithRetry(entities, attempt + 1));
     }, backoff);
   }
-  renderCPUParticles(renderer, entity) {
+  renderCPUParticles(renderer, entity, worldOpacity) {
     const data = entity.particleData;
     const size = entity.maxParticles;
     const isMain = renderer === this.renderer;
@@ -1499,7 +1579,7 @@ var Scene = class _Scene {
       const pSize = data[idx + 6];
       const life = data[idx + 7];
       if (life === 0) continue;
-      const opacity = life < 0 ? entity.opacity : entity.opacity * Math.min(1, life);
+      const opacity = life < 0 ? worldOpacity : worldOpacity * Math.min(1, life);
       const scale = life >= 0 ? Math.min(1, life) : 1;
       if (isMain && this.pointRenderer) {
         this.pointRenderer.addCircle(x, y, pSize * scale, entity.baseColor, opacity);
@@ -1583,10 +1663,9 @@ var TextEntity = class extends Entity {
     this.a11yOffsetY = 0;
   }
   isPointInside(globalX, globalY) {
-    const pos = this.getGlobalPosition();
-    const lx = globalX - pos.x;
-    const ly = globalY - pos.y;
-    return lx >= 0 && lx <= this.width && ly >= 0 && ly <= this.height;
+    const local = this.worldToLocal(globalX, globalY);
+    if (!local) return false;
+    return local.x >= 0 && local.x <= this.width && local.y >= 0 && local.y <= this.height;
   }
   render(renderer) {
     const currentFill = this.isHovered ? this.hoveredFillStyle : this.fillStyle;
@@ -1801,10 +1880,9 @@ var SplineEntity = class extends Entity {
    * this method already calls it as a refinement when it is overridden.
    */
   isPointInside(globalX, globalY) {
-    const pos = this.getGlobalPosition();
-    const scale = this.getWorldScale();
-    const lx = (globalX - pos.x) / (scale.x || 1);
-    const ly = (globalY - pos.y) / (scale.y || 1);
+    const local = this.worldToLocal(globalX, globalY);
+    if (!local) return false;
+    const { x: lx, y: ly } = local;
     const inAabb = lx >= this.bounds.x && lx <= this.bounds.x + this.bounds.width && ly >= this.bounds.y && ly <= this.bounds.y + this.bounds.height;
     if (!inAabb) return false;
     const refined = this.hitTestCurve(lx, ly);
@@ -2088,6 +2166,7 @@ var DOMPortalEntity = class extends Entity {
   lastHeight = "";
   lastTransform = "";
   lastZIndex = "";
+  lastOpacity = "";
   constructor(domElement, width, height, id) {
     super(id);
     this.domElement = domElement;
@@ -2138,22 +2217,15 @@ var DOMPortalEntity = class extends Entity {
     }
   }
   isPointInside(globalX, globalY) {
-    const pos = this.getGlobalPosition();
-    const scale = this.getWorldScale();
-    const rot = this.getWorldRotation();
-    const dx = globalX - pos.x;
-    const dy = globalY - pos.y;
-    const cos = Math.cos(-rot);
-    const sin = Math.sin(-rot);
-    const lx = (dx * cos - dy * sin) / scale.x;
-    const ly = (dx * sin + dy * cos) / scale.y;
     const w = this.width > 0 ? this.width : this.cachedWidth;
     const h = this.height > 0 ? this.height : this.cachedHeight;
-    return lx >= 0 && lx <= w && ly >= 0 && ly <= h;
+    const local = this.worldToLocal(globalX, globalY);
+    if (!local) return false;
+    return local.x >= 0 && local.x <= w && local.y >= 0 && local.y <= h;
   }
-  add(child) {
+  add(_child) {
     console.warn(`DOMPortalEntity (${this.id}) is a leaf node. Child entities are not supported.`);
-    return super.add(child);
+    return this;
   }
   render() {
   }
@@ -2216,8 +2288,10 @@ export {
   computeLineSegments,
   createCanvasMeasurer,
   createWebGLPointRenderer,
+  isSafeUrl,
   isTweenConfig,
   loadSpline,
   parseColorToRGBA,
-  polySegmentToBezier
+  polySegmentToBezier,
+  sanitizeUrl
 };

package/dist/layout/LayoutWorkerManager.d.ts

@@ -7,6 +7,10 @@ export declare class LayoutWorkerManager {
     private seqIdCounter;
     private debounceTimers;
     private constructor();
+    private createWorker;
+    private ensureWorker;
+    private handleWorkerFailure;
+    destroy(): void;
     static getInstance(): LayoutWorkerManager;
     queueLayout(entityId: string, text: string, options: {
         fontId: string;

package/dist/layout.js

@@ -3,14 +3,14 @@
 
 
 
-var _chunk72WVPMSJjs = require('./chunk-72WVPMSJ.js');
+var _chunkVVOQNUBKjs = require('./chunk-VVOQNUBK.js');
 
 
-var _chunkRW6NC4RBjs = require('./chunk-RW6NC4RB.js');
+var _chunk6I53LI3Zjs = require('./chunk-6I53LI3Z.js');
 
 
 
 
 
 
-exports.LayoutEngine = _chunk72WVPMSJjs.LayoutEngine; exports.LayoutResultBuffer = _chunk72WVPMSJjs.LayoutResultBuffer; exports.LayoutWorkerManager = _chunkRW6NC4RBjs.LayoutWorkerManager; exports.computeLineSegments = _chunk72WVPMSJjs.computeLineSegments; exports.createCanvasMeasurer = _chunk72WVPMSJjs.createCanvasMeasurer;
+exports.LayoutEngine = _chunkVVOQNUBKjs.LayoutEngine; exports.LayoutResultBuffer = _chunkVVOQNUBKjs.LayoutResultBuffer; exports.LayoutWorkerManager = _chunk6I53LI3Zjs.LayoutWorkerManager; exports.computeLineSegments = _chunkVVOQNUBKjs.computeLineSegments; exports.createCanvasMeasurer = _chunkVVOQNUBKjs.createCanvasMeasurer;

package/dist/layout.mjs

@@ -3,10 +3,10 @@ import {
   LayoutResultBuffer,
   computeLineSegments,
   createCanvasMeasurer
-} from "./chunk-T456DL4P.mjs";
+} from "./chunk-LIOJ37MH.mjs";
 import {
   LayoutWorkerManager
-} from "./chunk-YA2J5ZH7.mjs";
+} from "./chunk-YSS44ADQ.mjs";
 export {
   LayoutEngine,
   LayoutResultBuffer,

package/dist/renderer/CanvasRenderer.d.ts

@@ -78,4 +78,10 @@ export declare class CanvasRenderer implements IRenderer {
         stop: number;
         color: string;
     }[]): any;
+    /**
+     * Canvas2D drawing contexts are automatically released when their
+     * `<canvas>` element is GC'd, so there's no explicit GPU handle to free.
+     * This method clears our internal batch state and is idempotent.
+     */
+    dispose(): void;
 }

package/dist/renderer/IRenderer.d.ts

@@ -175,4 +175,13 @@ export interface IRenderer {
         stop: number;
         color: string;
     }[]): any;
+    /**
+     * Release any backend-owned GPU textures / GL contexts / caches.
+     *
+     * Called by {@link Scene.destroy()} so renderers that hold scarce resources
+     * (e.g. a WebGL2 context — browsers cap concurrent contexts to ~16) clean up
+     * before GC. Implementations MUST be idempotent: a second call after a
+     * successful teardown must be a silent no-op, not throw.
+     */
+    dispose?(): void;
 }

package/dist/renderer/SVGRenderer.d.ts

@@ -57,6 +57,14 @@ export declare class SVGRenderer implements IRenderer {
     fillText(text: string, x: number, y: number, font: string, color: string | SVGLinearGradient): void;
     fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
     drawImage(source: any, dx: number, dy: number, dw: number, dh: number): void;
+    /**
+     * Embed SVG markup as an isolated nested image.
+     *
+     * This explicit path is used by `SVGEntity` during vector export. General
+     * `drawImage()` input remains subject to the URL policy and therefore still
+     * rejects caller-provided SVG data URLs.
+     */
+    drawSVG(source: string, dx: number, dy: number, dw: number, dh: number): void;
     flush(): void;
     createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
         stop: number;
@@ -66,4 +74,10 @@ export declare class SVGRenderer implements IRenderer {
     toXMLString(): string;
     private resolveGradient;
     private escapeXML;
+    private isSafeRasterDataUrl;
+    /**
+     * SVGRenderer accumulates strings in memory; nothing external is allocated.
+     * Drop the buffers for GC and become idempotent.
+     */
+    dispose(): void;
 }

package/dist/renderer/url.d.ts

@@ -0,0 +1,31 @@
+/**
+ * URL sanitization helpers used by accessibility sinks (shadow `<a>` elements,
+ * `window.open`, Markdown link renders, …) to prevent `javascript:` / `data:`
+ * URI-script injection.
+ *
+ * The goal is conservative: allow safe browsing/navigation schemes, rewrite
+ * everything else to a benign `#` placeholder so click handlers resolve without
+ * executing payload or compromising the host DOM.
+ */
+/**
+ * Sanitize a potentially untrusted `href` / URL string for projection onto
+ * an `<a>` element or a `window.open` call.
+ *
+ * Behaviour:
+ * 1. Returns `''` for `null`/`undefined`/non-string input.
+ * 2. Trims leading whitespace (browsers do this before scheme resolution).
+ * 3. If the URL is relative (no scheme, or starts with `#`, `?`, `/`, `./`),
+ *    returns it verbatim — relative navigation is never script-injectable.
+ * 4. If the URL parses with a scheme NOT in {@link SAFE_SCHEMES}, returns `'#'`
+ *    to keep the link non-empty but inert.
+ * 5. Otherwise returns the canonical `URL.toString()` form.
+ *
+ * The function never throws; malformed input falls back to `'#'`.
+ */
+export declare function sanitizeUrl(href: string | null | undefined): string;
+/**
+ * Narrower guard used by link renderers that already know they hold an
+ * absolute URL: returns `true` if `urlStr` uses a scheme in
+ * {@link SAFE_SCHEMES}, `false` otherwise. Relative URLs are considered safe.
+ */
+export declare function isSafeUrl(urlStr: string): boolean;

package/dist/renderer.js

@@ -4,11 +4,11 @@
 
 
 
-var _chunkLIX7DJTIjs = require('./chunk-LIX7DJTI.js');
+var _chunkTXA3LZDMjs = require('./chunk-TXA3LZDM.js');
 
 
 
 
 
 
-exports.CanvasRenderer = _chunkLIX7DJTIjs.CanvasRenderer; exports.SVGRenderer = _chunkLIX7DJTIjs.SVGRenderer; exports.WebGPUParticleSystemManager = _chunkLIX7DJTIjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkLIX7DJTIjs.createWebGLPointRenderer; exports.parseColorToRGBA = _chunkLIX7DJTIjs.parseColorToRGBA;
+exports.CanvasRenderer = _chunkTXA3LZDMjs.CanvasRenderer; exports.SVGRenderer = _chunkTXA3LZDMjs.SVGRenderer; exports.WebGPUParticleSystemManager = _chunkTXA3LZDMjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkTXA3LZDMjs.createWebGLPointRenderer; exports.parseColorToRGBA = _chunkTXA3LZDMjs.parseColorToRGBA;