@vectojs/core 0.2.2 → 0.2.4

package/dist/{chunk-H3QIE77O.mjs → chunk-P6MDWIEX.mjs}

@@ -1,6 +1,6 @@
 import {
   LayoutWorkerManager
-} from "./chunk-YA2J5ZH7.mjs";
+} from "./chunk-B3Z3JEJH.mjs";
 
 // src/math/SpringPhysics.ts
 var SpringPhysics = class {
@@ -128,14 +128,16 @@ var VectoJSEvent = class {
   nativeEvent;
   /** Whether the event bubbles past its target (capture always runs). */
   bubbles;
+  explicitScenePoint;
   stopped = false;
   stoppedImmediate = false;
-  constructor(type, target, nativeEvent, bubbles = true) {
+  constructor(type, target, nativeEvent, bubbles = true, scenePoint) {
     this.type = type;
     this.target = target;
     this.currentTarget = target;
     this.nativeEvent = nativeEvent;
     this.bubbles = bubbles;
+    this.explicitScenePoint = scenePoint;
   }
   /** Stop the event from reaching the next node in the propagation path. */
   stopPropagation() {
@@ -178,6 +180,51 @@ var VectoJSEvent = class {
   get clientY() {
     return this.nativeEvent?.clientY;
   }
+  get resolvedScenePoint() {
+    if (this.explicitScenePoint) return this.explicitScenePoint;
+    const native = this.nativeEvent;
+    if (native?.vectoSceneX !== void 0 && native.vectoSceneY !== void 0) {
+      return { x: native.vectoSceneX, y: native.vectoSceneY };
+    }
+    if (native?.clientX === void 0 || native.clientY === void 0) return void 0;
+    const scene = this.target.scene;
+    return scene?.clientToScene?.(native.clientX, native.clientY) ?? {
+      x: native.clientX,
+      y: native.clientY
+    };
+  }
+  /** Pointer X in the Scene's logical coordinate space. */
+  get sceneX() {
+    return this.resolvedScenePoint?.x;
+  }
+  /** Pointer Y in the Scene's logical coordinate space. */
+  get sceneY() {
+    return this.resolvedScenePoint?.y;
+  }
+  /** Pointer X local to the entity whose listener is currently running. */
+  get localX() {
+    const point = this.resolvedScenePoint;
+    if (!point) return void 0;
+    return this.currentTarget.worldToLocal(point.x, point.y)?.x;
+  }
+  /** Pointer Y local to the entity whose listener is currently running. */
+  get localY() {
+    const point = this.resolvedScenePoint;
+    if (!point) return void 0;
+    return this.currentTarget.worldToLocal(point.x, point.y)?.y;
+  }
+  get shiftKey() {
+    return !!this.nativeEvent?.shiftKey;
+  }
+  get ctrlKey() {
+    return !!this.nativeEvent?.ctrlKey;
+  }
+  get altKey() {
+    return !!this.nativeEvent?.altKey;
+  }
+  get metaKey() {
+    return !!this.nativeEvent?.metaKey;
+  }
   /** Native key, if this wraps a keyboard event. */
   get key() {
     return this.nativeEvent?.key;
@@ -412,17 +459,28 @@ var Entity = class {
    * that need to seed a starting state (e.g. the presence helper's enter `from`).
    */
   setImmediate(prop, v) {
+    const existing = this._drivers.get(prop);
+    if (existing) this._settleDriver(existing);
     this._drivers.delete(prop);
     this._applyAnimated(prop, v);
   }
+  _settleDriver(driver) {
+    const active = driver;
+    const onDone = active.onDone;
+    active.onDone = void 0;
+    onDone?.();
+  }
   _spawnDriver(prop, to, cfg) {
     if (prop !== "opacity" && this.scene?.prefersReducedMotion) {
+      const existing2 = this._drivers.get(prop);
+      if (existing2) this._settleDriver(existing2);
       this._drivers.delete(prop);
       this._applyAnimated(prop, to);
       return;
     }
     const existing = this._drivers.get(prop);
     if (existing) {
+      this._settleDriver(existing);
       existing.retarget(to);
       return;
     }
@@ -477,7 +535,7 @@ var Entity = class {
       driver.tick(dt);
       if (driver.isDone()) {
         this._applyAnimated(prop, driver.target);
-        driver.onDone?.();
+        this._settleDriver(driver);
         this._drivers.delete(prop);
       } else {
         this._applyAnimated(prop, driver.value);
@@ -621,19 +679,95 @@ var Entity = class {
    * @returns World-space {@link Point} for this entity.
    */
   getGlobalPosition() {
-    let px = this.x;
-    let py = this.y;
-    let curr = this.parent;
-    while (curr && curr.id !== "root") {
-      const cos = Math.cos(curr.rotation);
-      const sin = Math.sin(curr.rotation);
-      const rotatedX = px * cos - py * sin;
-      const rotatedY = px * sin + py * cos;
-      px = curr.x + curr.scaleX * rotatedX;
-      py = curr.y + curr.scaleY * rotatedY;
-      curr = curr.parent;
+    return this.localToWorld(0, 0);
+  }
+  /**
+   * Return the exact accumulated Canvas `T * S * R` transform for this entity.
+   */
+  getWorldTransform() {
+    const path = this.id === "root" ? [] : [this];
+    let ancestor = this.parent;
+    while (ancestor && ancestor.id !== "root") {
+      path.push(ancestor);
+      ancestor = ancestor.parent;
     }
-    return { x: px, y: py };
+    let a = 1;
+    let b = 0;
+    let c = 0;
+    let d = 1;
+    let e = 0;
+    let f = 0;
+    for (let i = path.length - 1; i >= 0; i--) {
+      const node = path[i];
+      const cos = Math.cos(node.rotation);
+      const sin = Math.sin(node.rotation);
+      const la = node.scaleX * cos;
+      const lb = node.scaleY * sin;
+      const lc = -node.scaleX * sin;
+      const ld = node.scaleY * cos;
+      const le = node.x;
+      const lf = node.y;
+      const nextA = a * la + c * lb;
+      const nextB = b * la + d * lb;
+      const nextC = a * lc + c * ld;
+      const nextD = b * lc + d * ld;
+      const nextE = a * le + c * lf + e;
+      const nextF = b * le + d * lf + f;
+      a = nextA;
+      b = nextB;
+      c = nextC;
+      d = nextD;
+      e = nextE;
+      f = nextF;
+    }
+    return { a, b, c, d, e, f };
+  }
+  /** Convert a point from this entity's local space to Scene/world space. */
+  localToWorld(localX, localY) {
+    const { a, b, c, d, e, f } = this.getWorldTransform();
+    return {
+      x: a * localX + c * localY + e,
+      y: b * localX + d * localY + f
+    };
+  }
+  /**
+   * Convert a Scene/world point into this entity's local space.
+   * Returns `null` when the accumulated transform is singular.
+   */
+  worldToLocal(worldX, worldY) {
+    const { a, b, c, d, e, f } = this.getWorldTransform();
+    const determinant = a * d - b * c;
+    if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-12) return null;
+    const x = worldX - e;
+    const y = worldY - f;
+    return {
+      x: (d * x - c * y) / determinant,
+      y: (-b * x + a * y) / determinant
+    };
+  }
+  /**
+   * Return the entity's local bounds transformed into a world-space AABB.
+   * Falls back to the entity's `[0, 0, width, height]` box when `getBounds()`
+   * does not provide a render-specific box.
+   */
+  getWorldBounds() {
+    const bounds = this.getBounds() ?? { x: 0, y: 0, width: this.width, height: this.height };
+    const { a, b, c, d, e, f } = this.getWorldTransform();
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = 0; i < 4; i++) {
+      const localX = i & 1 ? bounds.x + bounds.width : bounds.x;
+      const localY = i & 2 ? bounds.y + bounds.height : bounds.y;
+      const worldX = a * localX + c * localY + e;
+      const worldY = b * localX + d * localY + f;
+      minX = Math.min(minX, worldX);
+      minY = Math.min(minY, worldY);
+      maxX = Math.max(maxX, worldX);
+      maxY = Math.max(maxY, worldY);
+    }
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
   }
   /**
    * Accumulated world scale factors: this entity's own `scaleX`/`scaleY` times
@@ -705,12 +839,12 @@ var Entity = class {
    * Opt into the renderer's draw-call batching fast-path for point-cloud /
    * particle entities that draw as a single filled circle at their local origin.
    *
-   * When a leaf entity returns a {@link BatchCircle} and has uniform scale, the
-   * {@link Scene} skips its per-entity `save`/`translate`/`scale`/`rotate`/
-   * `restore` and {@link render}, emitting the circle through
-   * {@link IRenderer.fillCircle} so runs of same-color siblings coalesce into a
-   * single `fill()`. Returns `null` by default (normal render path). Read each
-   * frame, so an animated color/radius is honored.
+   * When a leaf entity returns a {@link BatchCircle} and its accumulated
+   * transform is representable by the selected batch backend, the {@link Scene}
+   * skips its per-entity `save`/`translate`/`scale`/`rotate`/`restore` and
+   * {@link render}. Canvas mode or an unsupported affine transform uses the
+   * normal render path, so implementations must keep {@link render} correct.
+   * Returns `null` by default. Read each frame, so animated color/radius works.
    *
    * @returns The circle to batch, or `null` to use the normal {@link render} path.
    */
@@ -893,22 +1027,21 @@ var MSDFTextEntity = class extends Entity {
   }
   isPointInside(globalX, globalY) {
     if (!this.layoutResult) return false;
-    const pos = this.getGlobalPosition();
-    const scale = this.getWorldScale();
-    const lx = (globalX - pos.x) / scale.x;
-    const ly = (globalY - pos.y) / scale.y;
-    return lx >= 0 && lx <= this.layoutResult.width && ly >= 0 && ly <= this.layoutResult.height;
+    const local = this.worldToLocal(globalX, globalY);
+    if (!local) return false;
+    return local.x >= 0 && local.x <= this.layoutResult.width && local.y >= 0 && local.y <= this.layoutResult.height;
   }
   render(renderer) {
     if (!this.layoutResult) return;
     const scene = this.scene;
-    if (scene && scene.pointRenderer && scene.glCanvas) {
+    const world = this.getWorldTransform();
+    const worldScaleX = Math.hypot(world.a, world.b);
+    const worldScaleY = Math.hypot(world.c, world.d);
+    const orthogonalTolerance = Math.max(1, worldScaleX * worldScaleY) * 1e-6;
+    const canUsePointGlyphs = Number.isFinite(worldScaleX) && Number.isFinite(worldScaleY) && world.a * world.d - world.b * world.c >= 0 && Math.abs(world.a * world.c + world.b * world.d) <= orthogonalTolerance;
+    if (scene && scene.pointRenderer && scene.glCanvas && canUsePointGlyphs) {
       scene.pointRenderer.setMSDFTexture(this.texture, this.font.distanceRange);
-      const globalPos = this.getGlobalPosition();
-      const scale = this.getWorldScale();
-      const worldRot = this.getWorldRotation();
-      const rCos = Math.cos(worldRot);
-      const rSin = Math.sin(worldRot);
+      const worldRot = Math.atan2(world.b, world.a);
       const len2 = this.layoutResult.codePoints.length;
       for (let i = 0; i < len2; i++) {
         const code = this.layoutResult.codePoints[i];
@@ -920,12 +1053,12 @@ var MSDFTextEntity = class extends Entity {
         const { atlasBounds: ab, planeBounds: pb } = def;
         const aw = this.font.atlasWidth;
         const ah = this.font.atlasHeight;
-        const lx = (nodeX + pb.left * this.fontSize) * scale.x;
-        const ly = (nodeY - pb.top * this.fontSize) * scale.y;
-        const glyphX = globalPos.x + lx * rCos - ly * rSin;
-        const glyphY = globalPos.y + lx * rSin + ly * rCos;
-        const glyphW = (pb.right - pb.left) * this.fontSize * scale.x;
-        const glyphH = (pb.top - pb.bottom) * this.fontSize * scale.y;
+        const lx = nodeX + pb.left * this.fontSize;
+        const ly = nodeY - pb.top * this.fontSize;
+        const glyphX = world.a * lx + world.c * ly + world.e;
+        const glyphY = world.b * lx + world.d * ly + world.f;
+        const glyphW = (pb.right - pb.left) * this.fontSize * worldScaleX;
+        const glyphH = (pb.top - pb.bottom) * this.fontSize * worldScaleY;
         const v0 = this.font.data.atlas.yOrigin === "bottom" ? 1 - ab.top / ah : ab.top / ah;
         const v1 = this.font.data.atlas.yOrigin === "bottom" ? 1 - ab.bottom / ah : ab.bottom / ah;
         const colorVal = packedStyle >>> 8;
@@ -985,6 +1118,36 @@ var MSDFTextEntity = class extends Entity {
 };
 
 // src/text/SVGEntity.ts
+function isSvgWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+function readSvgAttribute(source, name) {
+  const lowerSource = source.toLowerCase();
+  const svgStart = lowerSource.indexOf("<svg");
+  if (svgStart < 0) return null;
+  const tagEnd = source.indexOf(">", svgStart + 4);
+  if (tagEnd < 0) return null;
+  const tag = source.slice(svgStart + 4, tagEnd);
+  const lowerTag = tag.toLowerCase();
+  const lowerName = name.toLowerCase();
+  for (let i = 0; i < tag.length; i++) {
+    const before = i === 0 ? " " : tag[i - 1];
+    if (!isSvgWhitespace(before)) continue;
+    if (!lowerTag.startsWith(lowerName, i)) continue;
+    let cursor = i + lowerName.length;
+    while (cursor < tag.length && isSvgWhitespace(tag[cursor])) cursor++;
+    if (tag[cursor] !== "=") continue;
+    cursor++;
+    while (cursor < tag.length && isSvgWhitespace(tag[cursor])) cursor++;
+    const quote = tag[cursor];
+    if (quote !== '"' && quote !== "'") continue;
+    const valueStart = cursor + 1;
+    const valueEnd = tag.indexOf(quote, valueStart);
+    if (valueEnd < 0) return null;
+    return tag.slice(valueStart, valueEnd);
+  }
+  return null;
+}
 var SVGEntity = class extends Entity {
   svgSource = "";
   imageBitmap = null;
@@ -1036,17 +1199,17 @@ var SVGEntity = class extends Entity {
           }
         }
       } catch (e) {
-        console.error("Failed parsing SVG via DOMParser, falling back to regex:", e);
+        console.error("Failed parsing SVG via DOMParser, falling back to attribute scan:", e);
       }
     } else {
-      const wMatch = /<svg[^>]*\bwidth\s*=\s*["']([^"']+)["']/i.exec(this.svgSource);
-      const hMatch = /<svg[^>]*\bheight\s*=\s*["']([^"']+)["']/i.exec(this.svgSource);
-      const vbMatch = /<svg[^>]*\bviewBox\s*=\s*["']([^"']+)["']/i.exec(this.svgSource);
-      if (wMatch && hMatch) {
-        width = parseFloat(wMatch[1]) || 100;
-        height = parseFloat(hMatch[1]) || 100;
-      } else if (vbMatch) {
-        const parts = vbMatch[1].split(/[\s,]+/).map(parseFloat);
+      const wAttr = readSvgAttribute(this.svgSource, "width");
+      const hAttr = readSvgAttribute(this.svgSource, "height");
+      const vbAttr = readSvgAttribute(this.svgSource, "viewBox");
+      if (wAttr && hAttr) {
+        width = parseFloat(wAttr) || 100;
+        height = parseFloat(hAttr) || 100;
+      } else if (vbAttr) {
+        const parts = vbAttr.split(/[\s,]+/).map(parseFloat);
         if (parts.length === 4) {
           width = parts[2];
           height = parts[3];
@@ -1138,22 +1301,14 @@ var SVGEntity = class extends Entity {
     img.src = this.blobURL;
   }
   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;
-    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(r) {
-    const isSVGExporter = typeof r.toXMLString === "function";
-    if (isSVGExporter) {
-      const dataUri = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(this.svgSource);
-      r.drawImage({ src: dataUri }, 0, 0, this.width, this.height);
+    const svgRenderer = r;
+    if (typeof svgRenderer.drawSVG === "function") {
+      svgRenderer.drawSVG(this.svgSource, 0, 0, this.width, this.height);
       return;
     }
     const scale = this.getWorldScale();

package/dist/{chunk-LIX7DJTI.js → chunk-TPNADFNN.js}

@@ -185,9 +185,100 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
     }
     return grad;
   }
+  /**
+   * 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() {
+    this.batchCount = 0;
+    this.batchColor = "";
+    this.batchAlpha = 1;
+    this.batchActive = false;
+  }
 }, _class.__initStatic(), _class);
 
+// src/renderer/url.ts
+var SAFE_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:", "ftp:"]);
+var SCHEME_PATTERN = /^[a-z][a-z\d+.-]*$/i;
+function normalizeSchemeCandidate(value) {
+  let result = "";
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code > 32 && (code < 127 || code > 159)) result += character;
+  }
+  return result;
+}
+function hasSafeSchemeOrIsRelative(url) {
+  const colonIndex = url.indexOf(":");
+  if (colonIndex < 0) return true;
+  const candidate = normalizeSchemeCandidate(url.slice(0, colonIndex));
+  if (!SCHEME_PATTERN.test(candidate)) return true;
+  return SAFE_SCHEMES.has(`${candidate.toLowerCase()}:`);
+}
+function sanitizeUrl(href) {
+  if (typeof href !== "string") return "";
+  const trimmed = href.trim();
+  if (trimmed === "") return "";
+  return hasSafeSchemeOrIsRelative(trimmed) ? trimmed : "#";
+}
+function isSafeUrl(urlStr) {
+  if (typeof urlStr !== "string") return false;
+  const trimmed = urlStr.trim();
+  if (trimmed === "") return false;
+  return hasSafeSchemeOrIsRelative(trimmed);
+}
+
 // src/renderer/SVGRenderer.ts
+function parseFontSizeToken(font) {
+  for (let i = 0; i < font.length; i++) {
+    const ch = font[i];
+    if (!(ch >= "0" && ch <= "9" || ch === ".")) continue;
+    let j = i + 1;
+    while (j < font.length) {
+      const next = font[j];
+      if (next >= "0" && next <= "9" || next === ".") {
+        j++;
+      } else {
+        break;
+      }
+    }
+    const unit = font.startsWith("rem", j) ? "rem" : font.startsWith("em", j) ? "em" : font.startsWith("px", j) ? "px" : null;
+    if (!unit) {
+      i = j;
+      continue;
+    }
+    let end = j + unit.length;
+    if (font[end] === "/") {
+      end++;
+      while (end < font.length && font[end] !== " " && font[end] !== "	") end++;
+    }
+    const value = Number.parseFloat(font.slice(i, j));
+    return Number.isFinite(value) ? { value, unit, start: i, end } : null;
+  }
+  return null;
+}
+function fontFamilyFromShorthand(font, sizeToken) {
+  const withoutSize = sizeToken ? `${font.slice(0, sizeToken.start)} ${font.slice(sizeToken.end)}`.trim() : font.trim();
+  const family = withoutSize.split(" ").map((part) => part.trim()).filter(
+    (part) => part && ![
+      "bold",
+      "italic",
+      "oblique",
+      "normal",
+      "900",
+      "800",
+      "700",
+      "600",
+      "500",
+      "400",
+      "300",
+      "200",
+      "100"
+    ].includes(part.toLowerCase())
+  ).join(" ");
+  return family || "sans-serif";
+}
 var SVGRenderer = (_class2 = class {
   
   
@@ -395,7 +486,7 @@ var SVGRenderer = (_class2 = class {
   }
   fill(colorOrGradient) {
     this.flush();
-    const fillVal = this.resolveGradient(colorOrGradient);
+    const fillVal = this.escapeXML(this.resolveGradient(colorOrGradient));
     const dStr = this.currentPath.join(" ");
     const transformStr = `matrix(${this.ma},${this.mb},${this.mc},${this.md},${this.me},${this.mf})`;
     this.buffer.push(
@@ -404,7 +495,7 @@ var SVGRenderer = (_class2 = class {
   }
   stroke(colorOrGradient, lineWidth = 1) {
     this.flush();
-    const strokeVal = this.resolveGradient(colorOrGradient);
+    const strokeVal = this.escapeXML(this.resolveGradient(colorOrGradient));
     const dStr = this.currentPath.join(" ");
     const transformStr = `matrix(${this.ma},${this.mb},${this.mc},${this.md},${this.me},${this.mf})`;
     this.buffer.push(
@@ -413,18 +504,18 @@ var SVGRenderer = (_class2 = class {
   }
   fillText(text, x, y, font, color) {
     this.flush();
-    const sizeMatch = font.match(/(\d+(?:\.\d+)?)(px|em|rem)/);
-    let fontSize = sizeMatch ? parseFloat(sizeMatch[1]) : 16;
-    if (sizeMatch && sizeMatch[2] !== "px") {
+    const sizeToken = parseFontSizeToken(font);
+    let fontSize = sizeToken ? sizeToken.value : 16;
+    if (sizeToken && sizeToken.unit !== "px") {
       fontSize = fontSize * 16;
     }
-    const styleMatch = font.match(/(italic|oblique)/i);
-    const fontWeightMatch = font.match(/(bold|[1-9]00)/i);
-    const fontStyle = styleMatch ? styleMatch[1].toLowerCase() : "normal";
-    const fontWeight = fontWeightMatch ? fontWeightMatch[1].toLowerCase() : "normal";
-    const cleanFont = font.replace(/\d+(?:\.\d+)?(px|em|rem)(?:\/\d+(?:\.\d+)?(?:px|em|rem|%)?)?/, "").trim();
-    const fontFamily = cleanFont.replace(/(bold|italic|normal|600|500|400|300|100)\s+/gi, "").trim() || "sans-serif";
-    const fillVal = this.resolveGradient(color);
+    const lowerFont = font.toLowerCase();
+    const fontStyle = lowerFont.includes("italic") ? "italic" : lowerFont.includes("oblique") ? "oblique" : "normal";
+    const fontWeight = lowerFont.includes("bold") ? "bold" : _nullishCoalesce(["900", "800", "700", "600", "500", "400", "300", "200", "100"].find(
+      (weight) => lowerFont.includes(weight)
+    ), () => ( "normal"));
+    const fontFamily = fontFamilyFromShorthand(font, sizeToken);
+    const fillVal = this.escapeXML(this.resolveGradient(color));
     const transformStr = `matrix(${this.ma},${this.mb},${this.mc},${this.md},${this.me},${this.mf})`;
     this.buffer.push(
       `<g transform="${transformStr}"><text x="${x}" y="${y}" font-size="${fontSize}" font-weight="${fontWeight}" font-style="${fontStyle}" font-family="${this.escapeXML(fontFamily)}" fill="${fillVal}" opacity="${this.globalAlpha}">${this.escapeXML(text)}</text></g>`
@@ -446,7 +537,9 @@ var SVGRenderer = (_class2 = class {
   }
   drawImage(source, dx, dy, dw, dh) {
     this.flush();
-    const href = typeof _optionalChain([source, 'optionalAccess', _ => _.toDataURL]) === "function" ? source.toDataURL() : _optionalChain([source, 'optionalAccess', _2 => _2.src]) || "";
+    const fromCanvas2 = typeof _optionalChain([source, 'optionalAccess', _ => _.toDataURL]) === "function";
+    const rawHref = fromCanvas2 ? source.toDataURL() : _optionalChain([source, 'optionalAccess', _2 => _2.src]) || "";
+    const href = fromCanvas2 && this.isSafeRasterDataUrl(rawHref) ? rawHref : sanitizeUrl(String(rawHref));
     const transformStr = `matrix(${this.ma},${this.mb},${this.mc},${this.md},${this.me},${this.mf})`;
     if (href) {
       this.buffer.push(
@@ -459,6 +552,21 @@ var SVGRenderer = (_class2 = class {
       console.warn("drawImage source fallback triggered");
     }
   }
+  /**
+   * 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, dx, dy, dw, dh) {
+    this.flush();
+    const href = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(source)}`;
+    const transformStr = `matrix(${this.ma},${this.mb},${this.mc},${this.md},${this.me},${this.mf})`;
+    this.buffer.push(
+      `<image href="${this.escapeXML(href)}" x="${dx}" y="${dy}" width="${dw}" height="${dh}" transform="${transformStr}" />`
+    );
+  }
   flush() {
     if (!this.batchActive || this.batchCircles.length === 0) return;
     let d = "";
@@ -566,6 +674,17 @@ var SVGRenderer = (_class2 = class {
       }
     });
   }
+  isSafeRasterDataUrl(value) {
+    return typeof value === "string" && /^data:image\/(?:png|jpeg|gif|webp);base64,[a-z\d+/=\s]*$/i.test(value);
+  }
+  /**
+   * SVGRenderer accumulates strings in memory; nothing external is allocated.
+   * Drop the buffers for GC and become idempotent.
+   */
+  dispose() {
+    this.clear();
+    this.gradientCache.clear();
+  }
 }, _class2);
 
 // src/renderer/colorParse.ts
@@ -831,6 +950,7 @@ function createWebGLPointRenderer(canvas) {
   let logicalW = 0;
   let logicalH = 0;
   let dpr = 1;
+  let destroyed = false;
   return {
     resize(width, height) {
       logicalW = width;
@@ -1037,6 +1157,8 @@ function createWebGLPointRenderer(canvas) {
       gl.bindVertexArray(null);
     },
     destroy() {
+      if (destroyed) return;
+      destroyed = true;
       gl.deleteBuffer(pointBuffer);
       gl.deleteBuffer(rectBuffer);
       gl.deleteBuffer(spriteBuffer);
@@ -1326,10 +1448,14 @@ var WebGPUParticleSystemManager = (_class3 = class {
     if (!this.computePipeline || !entity.computeBindGroup) return;
     const uniformArray = new Float32Array(20);
     const color = parseColorToRGBA(entity.baseColor);
+    let opacity = 1;
+    for (let current = entity; current; current = current.parent) {
+      opacity *= current.opacity;
+    }
     uniformArray[0] = color[0];
     uniformArray[1] = color[1];
     uniformArray[2] = color[2];
-    uniformArray[3] = color[3];
+    uniformArray[3] = color[3] * opacity;
     const mActive = !isNaN(mouseX) && !isNaN(mouseY) && mouseX > -9e3 && mouseY > -9e3;
     uniformArray[4] = mActive ? mouseX : -9999;
     uniformArray[5] = mActive ? mouseY : -9999;
@@ -1377,4 +1503,6 @@ var WebGPUParticleSystemManager = (_class3 = class {
 
 
 
-exports.CanvasRenderer = CanvasRenderer; exports.SVGRenderer = SVGRenderer; exports.parseColorToRGBA = parseColorToRGBA; exports.createWebGLPointRenderer = createWebGLPointRenderer; exports.WebGPUParticleSystemManager = WebGPUParticleSystemManager;
+
+
+exports.CanvasRenderer = CanvasRenderer; exports.sanitizeUrl = sanitizeUrl; exports.isSafeUrl = isSafeUrl; exports.SVGRenderer = SVGRenderer; exports.parseColorToRGBA = parseColorToRGBA; exports.createWebGLPointRenderer = createWebGLPointRenderer; exports.WebGPUParticleSystemManager = WebGPUParticleSystemManager;