@vectojs/core 0.1.0

package/dist/chunk-53DAQC3U.js

@@ -0,0 +1,907 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;
+
+var _chunkRW6NC4RBjs = require('./chunk-RW6NC4RB.js');
+
+// src/tree/Entity.ts
+var VectoJSEvent = (_class = class {
+  /** The event name. */
+  
+  /** The entity the event originated on. */
+  
+  /** The entity whose listeners are currently running (updated per node). */
+  
+  /** The wrapped browser event, if any. */
+  
+  /** Whether the event bubbles past its target (capture always runs). */
+  
+  __init() {this.stopped = false}
+  __init2() {this.stoppedImmediate = false}
+  constructor(type, target, nativeEvent, bubbles = true) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.type = type;
+    this.target = target;
+    this.currentTarget = target;
+    this.nativeEvent = nativeEvent;
+    this.bubbles = bubbles;
+  }
+  /** Stop the event from reaching the next node in the propagation path. */
+  stopPropagation() {
+    this.stopped = true;
+  }
+  /** Stop propagation AND skip any remaining listeners on the current node. */
+  stopImmediatePropagation() {
+    this.stopped = true;
+    this.stoppedImmediate = true;
+  }
+  /** Forward to the native event's `preventDefault` (e.g. stop page scroll). */
+  preventDefault() {
+    _optionalChain([this, 'access', _ => _.nativeEvent, 'optionalAccess', _2 => _2.preventDefault, 'optionalCall', _3 => _3()]);
+  }
+  /** Whether {@link stopPropagation} has been called. */
+  get propagationStopped() {
+    return this.stopped;
+  }
+  /** Whether {@link stopImmediatePropagation} has been called. */
+  get immediatePropagationStopped() {
+    return this.stoppedImmediate;
+  }
+  /** Whether the native event's default action was prevented. */
+  get defaultPrevented() {
+    return !!_optionalChain([this, 'access', _4 => _4.nativeEvent, 'optionalAccess', _5 => _5.defaultPrevented]);
+  }
+  /** Native horizontal wheel delta, if this wraps a `WheelEvent`. */
+  get deltaX() {
+    return _optionalChain([this, 'access', _6 => _6.nativeEvent, 'optionalAccess', _7 => _7.deltaX]);
+  }
+  /** Native vertical wheel delta, if this wraps a `WheelEvent`. */
+  get deltaY() {
+    return _optionalChain([this, 'access', _8 => _8.nativeEvent, 'optionalAccess', _9 => _9.deltaY]);
+  }
+  /** Native pointer X, if this wraps a pointer/mouse event. */
+  get clientX() {
+    return _optionalChain([this, 'access', _10 => _10.nativeEvent, 'optionalAccess', _11 => _11.clientX]);
+  }
+  /** Native pointer Y, if this wraps a pointer/mouse event. */
+  get clientY() {
+    return _optionalChain([this, 'access', _12 => _12.nativeEvent, 'optionalAccess', _13 => _13.clientY]);
+  }
+  /** Native key, if this wraps a keyboard event. */
+  get key() {
+    return _optionalChain([this, 'access', _14 => _14.nativeEvent, 'optionalAccess', _15 => _15.key]);
+  }
+}, _class);
+var Entity = (_class2 = class {
+  
+  __init3() {this.children = []}
+  __init4() {this.parent = null}
+  /**
+   * Walk up the parent chain to find the scene this entity is currently attached to.
+   */
+  get scene() {
+    if (this._scene) return this._scene;
+    return this.parent ? this.parent.scene : null;
+  }
+  __init5() {this.x = 0}
+  __init6() {this.y = 0}
+  __init7() {this.scaleX = 1}
+  __init8() {this.scaleY = 1}
+  __init9() {this.rotation = 0}
+  __init10() {this.opacity = 1}
+  __init11() {this.isDOMPortal = false}
+  __init12() {this._interactive = false}
+  get interactive() {
+    return this._interactive;
+  }
+  set interactive(val) {
+    if (this._interactive !== val) {
+      this._interactive = val;
+      const s = this.scene;
+      if (s) {
+        s.a11yNeedsReorder = true;
+        s.markDirty();
+      }
+    }
+  }
+  __init13() {this.width = 0}
+  __init14() {this.height = 0}
+  __init15() {this.a11yOffsetX = 0}
+  __init16() {this.a11yOffsetY = 0}
+  /**
+   * Opt in to a viewport-filling accessibility/automation shadow node even when
+   * this entity has no intrinsic box (`width`/`height` of `0`). Use for
+   * full-screen, boundless interaction surfaces (e.g. an infinite-canvas graph)
+   * that need global pointer events. The node is mounted behind all other shadow
+   * nodes, so on-top components stay clickable.
+   */
+  __init17() {this.a11yFullViewport = false}
+  /**
+   * Clip this node's children to its local box (`[0,0]–[width,height]`) while
+   * rendering. Combined with translating a content child, this is how
+   * scroll/overflow containers (e.g. `ScrollView`) keep their content inside a
+   * fixed viewport. Off by default (children render unclipped). Canvas2D only.
+   */
+  __init18() {this.clipChildren = false}
+  __init19() {this.listeners = /* @__PURE__ */ new Map()}
+  /** Capture-phase listeners (fired root→target before bubble). */
+  __init20() {this.captureListeners = /* @__PURE__ */ new Map()}
+  __init21() {this.animations = []}
+  constructor(id) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this);_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this);_class2.prototype.__init17.call(this);_class2.prototype.__init18.call(this);_class2.prototype.__init19.call(this);_class2.prototype.__init20.call(this);_class2.prototype.__init21.call(this);
+    this.id = id || `entity_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Append a child entity to this node's children array.
+   *
+   * @param child - The entity to add as a child.
+   * @returns `this` for method chaining.
+   */
+  add(child) {
+    child.parent = this;
+    this.children.push(child);
+    const s = this.scene;
+    if (s) {
+      s.a11yNeedsReorder = true;
+      s.markDirty();
+    }
+    return this;
+  }
+  /**
+   * Remove a child entity from this node.
+   *
+   * @param child - The entity to remove.
+   * @returns `this` for method chaining.
+   */
+  remove(child) {
+    const index = this.children.indexOf(child);
+    if (index !== -1) {
+      this.children.splice(index, 1);
+      child.parent = null;
+      const s = this.scene;
+      if (s) {
+        s.a11yNeedsReorder = true;
+        s.markDirty();
+      }
+    }
+    return this;
+  }
+  /**
+   * Set the local position of this entity.
+   *
+   * @param x - Horizontal position in local space.
+   * @param y - Vertical position in local space.
+   * @returns `this` for method chaining.
+   * @example entity.setPosition(100, 200);
+   */
+  setPosition(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  /**
+   * Queue a tween animation toward the specified target property values.
+   *
+   * Multiple calls chain animations sequentially.  Only numeric properties
+   * are interpolated; non-numeric values are ignored.
+   *
+   * @param targetProps - Partial set of numeric properties to tween to.
+   * @param durationMs - Duration of the tween in milliseconds.
+   * @returns `this` for method chaining.
+   * @example entity.animate({ x: 400, opacity: 0 }, 500);
+   */
+  animate(targetProps, durationMs) {
+    this.animations.push({
+      target: targetProps,
+      duration: durationMs,
+      startTime: -1,
+      startProps: {}
+    });
+    return this;
+  }
+  /**
+   * Advance the entity's internal state for one frame.
+   *
+   * Called automatically by the {@link Scene} render loop — override in
+   * subclasses to implement custom per-frame logic.
+   *
+   * @param dt - Elapsed time since the last frame in milliseconds.
+   * @param time - Absolute timestamp from `performance.now()`.
+   */
+  update(_dt, time) {
+    if (this.animations.length > 0) {
+      const anim = this.animations[0];
+      if (anim.startTime === -1) {
+        anim.startTime = time;
+        for (const key in anim.target) {
+          anim.startProps[key] = this[key];
+        }
+      }
+      const progress = Math.min((time - anim.startTime) / anim.duration, 1);
+      for (const key in anim.target) {
+        const start = anim.startProps[key];
+        const end = anim.target[key];
+        if (typeof start === "number" && typeof end === "number") {
+          const easeOut = progress * (2 - progress);
+          this[key] = start + (end - start) * easeOut;
+        }
+      }
+      if (progress >= 1) {
+        this.animations.shift();
+      }
+    }
+  }
+  /**
+   * Register a listener for a {@link VectoEvent}.
+   *
+   * Listeners run in the bubble phase by default; pass `{ capture: true }` for the
+   * capture phase (root→target). Bubble listeners also fire for the legacy
+   * {@link emit} (direct, self-only) path.
+   *
+   * @param event - The event name to listen for.
+   * @param callback - Handler invoked when the event fires.
+   * @param options - `{ capture }` to register for the capture phase.
+   * @returns `this` for method chaining.
+   * @example entity.on('click', (e) => console.log('clicked', e));
+   */
+  on(event, callback, options) {
+    const map = _optionalChain([options, 'optionalAccess', _16 => _16.capture]) ? this.captureListeners : this.listeners;
+    if (!map.has(event)) {
+      map.set(event, []);
+    }
+    map.get(event).push(callback);
+    return this;
+  }
+  /**
+   * Remove a previously registered event listener.
+   *
+   * @param event - The event name to stop listening to.
+   * @param callback - The exact handler reference passed to {@link on}.
+   * @param options - Must match the phase the listener was registered with.
+   * @returns `this` for method chaining.
+   */
+  off(event, callback, options) {
+    const handlers = (_optionalChain([options, 'optionalAccess', _17 => _17.capture]) ? this.captureListeners : this.listeners).get(event);
+    if (handlers) {
+      const idx = handlers.indexOf(callback);
+      if (idx !== -1) handlers.splice(idx, 1);
+    }
+    return this;
+  }
+  /**
+   * Tear down this entity: clear all animations, event listeners, and detach
+   * from parent. Call before discarding an entity to prevent memory leaks.
+   */
+  destroy() {
+    this.animations = [];
+    this.listeners.clear();
+    this.captureListeners.clear();
+    if (this.parent) {
+      this.parent.remove(this);
+    }
+  }
+  /**
+   * Dispatch a {@link VectoEvent} directly to this entity's bubble-phase listeners
+   * only — no tree propagation. Kept for component-internal/self events (e.g. a
+   * form control emitting its own `change`); use {@link dispatchEvent} for the
+   * capture/bubble path.
+   *
+   * @param event - The event name to dispatch.
+   * @param payload - Arbitrary data forwarded to each listener.
+   */
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.forEach((h) => h(payload));
+    }
+  }
+  /** Run one node's listeners for the event, honoring stopImmediatePropagation. */
+  fireListeners(node, map, event) {
+    const handlers = map.get(event.type);
+    if (!handlers) return;
+    event.currentTarget = node;
+    for (const h of handlers.slice()) {
+      h(event);
+      if (event.immediatePropagationStopped) return;
+    }
+  }
+  /**
+   * Dispatch a {@link VectoJSEvent} through the entity tree, DOM-style: a capture
+   * phase from the root down to `event.target`, then a bubble phase back up to the
+   * root. `event.stopPropagation()` halts the walk; `stopImmediatePropagation()`
+   * also skips the remaining listeners on the current node. A non-bubbling event
+   * only fires its target in the bubble phase (capture still runs).
+   *
+   * @param event - The event to propagate (its `target` defines the path).
+   */
+  dispatchEvent(event) {
+    const path = [];
+    for (let n = event.target; n; n = n.parent) path.push(n);
+    for (let i = path.length - 1; i >= 0; i--) {
+      if (event.propagationStopped) return;
+      this.fireListeners(path[i], path[i].captureListeners, event);
+    }
+    for (let i = 0; i < path.length; i++) {
+      if (event.propagationStopped) return;
+      this.fireListeners(path[i], path[i].listeners, event);
+      if (!event.bubbles) return;
+    }
+  }
+  /**
+   * Compute the entity's position in world/canvas space by accumulating
+   * local offsets up the scene-graph hierarchy using affine transformations (scale and rotation).
+   *
+   * @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 { x: px, y: py };
+  }
+  /**
+   * Accumulated world scale factors: this entity's own `scaleX`/`scaleY` times
+   * those of every ancestor (excluding the scene root). Useful for mapping a
+   * world-space point back into local space for hit-testing.
+   *
+   * @returns The world scale `{ x, y }`.
+   */
+  getWorldScale() {
+    let sx = this.scaleX;
+    let sy = this.scaleY;
+    let curr = this.parent;
+    while (curr && curr.id !== "root") {
+      sx *= curr.scaleX;
+      sy *= curr.scaleY;
+      curr = curr.parent;
+    }
+    return { x: sx, y: sy };
+  }
+  /**
+   * Accumulated world rotation: this entity's own `rotation` plus
+   * that of every ancestor (excluding the scene root).
+   *
+   * @returns The accumulated world rotation in radians.
+   */
+  getWorldRotation() {
+    let rot = this.rotation;
+    let curr = this.parent;
+    while (curr && curr.id !== "root") {
+      rot += curr.rotation;
+      curr = curr.parent;
+    }
+    return rot;
+  }
+  /**
+   * Return `true` when the given world-space point lies within this entity's
+   * interactive hit area.
+   *
+   * @param globalX - World-space X coordinate.
+   * @param globalY - World-space Y coordinate.
+   * @returns Whether the point is inside this entity.
+   */
+  /**
+   * Describe this entity's semantics for the accessibility / automation shadow
+   * layer. Override in components to project a real `<button>`, `<a href>`, etc.
+   *
+   * The default returns `{}`, which `Scene.syncA11y` maps to a plain `div`
+   * (preserving the historical behavior of interactive entities).
+   *
+   * @returns The {@link A11yAttributes} for this entity's shadow node.
+   */
+  getA11yAttributes() {
+    return {};
+  }
+  /**
+   * Local-space axis-aligned bounding box of what this entity's {@link render}
+   * draws, used by {@link Scene} for viewport culling.
+   *
+   * Returns `null` by default, meaning "unknown bounds" — the entity is then
+   * never culled (always rendered). Override to return a {@link Bounds} so the
+   * scene can skip rendering it when it lies outside the viewport.
+   *
+   * @returns The local bounds, or `null` to opt out of culling.
+   */
+  getBounds() {
+    return null;
+  }
+  /**
+   * 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.
+   *
+   * @returns The circle to batch, or `null` to use the normal {@link render} path.
+   */
+  getBatchCircle() {
+    return null;
+  }
+  /**
+   * Opt into the GPU instanced-rectangle fast-path for a leaf entity that draws
+   * as a single filled rectangle from its local origin. Only used when the
+   * {@link Scene} runs a WebGL `pointBackend`; otherwise the entity renders
+   * normally via {@link render}. Returns `null` by default. Read each frame.
+   *
+   * @returns The rectangle to batch, or `null` for the normal render path.
+   */
+  getBatchRect() {
+    return null;
+  }
+  /**
+   * Whether this entity still has a queued/running tween animation.
+   *
+   * Used by {@link Scene}'s `onDemand` render mode to keep redrawing while an
+   * animation is in flight.
+   *
+   * @returns `true` if at least one animation remains.
+   */
+  hasPendingAnimations() {
+    return this.animations.length > 0;
+  }
+}, _class2);
+
+// src/text/MSDFFont.ts
+function kernKey(a, b) {
+  return a * 1114112 + b;
+}
+var MSDFFont = (_class3 = class _MSDFFont {
+  static __initStatic() {this.idCounter = 0}
+  
+  
+  __init22() {this.byCode = /* @__PURE__ */ new Map()}
+  __init23() {this.kern = /* @__PURE__ */ new Map()}
+  constructor(data) {;_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);
+    this.id = `font-${_MSDFFont.idCounter++}`;
+    this.data = data;
+    for (const g of data.glyphs) this.byCode.set(g.unicode, g);
+    for (const k of _nullishCoalesce(data.kerning, () => ( []))) this.kern.set(kernKey(k.unicode1, k.unicode2), k.advance);
+  }
+  /** Parse the `msdf-atlas-gen` JSON (string or already-parsed object). */
+  static parse(json) {
+    return new _MSDFFont(typeof json === "string" ? JSON.parse(json) : json);
+  }
+  /** Get a glyph's definition by its unicode value in O(1) time. */
+  getGlyph(unicode) {
+    return this.byCode.get(unicode);
+  }
+  /** Distance field range in atlas pixels (for the shader's `u_distanceRange`). */
+  get distanceRange() {
+    return this.data.atlas.distanceRange;
+  }
+  get atlasWidth() {
+    return this.data.atlas.width;
+  }
+  get atlasHeight() {
+    return this.data.atlas.height;
+  }
+  /**
+   * Lay `text` out at `fontSizePx`. Returns positioned quads (skipping glyphs the
+   * font doesn't contain), the widest line's advance, and the total block height.
+   * Honors `\n`, kerning pairs, and `letterSpacing`.
+   */
+  layout(text, fontSizePx, opts = {}) {
+    const { x = 0, y = 0, letterSpacing = 0 } = opts;
+    const { width: aw, height: ah, yOrigin } = this.data.atlas;
+    const { lineHeight, ascender } = this.data.metrics;
+    const glyphs = [];
+    let penX = x;
+    let line = 0;
+    let maxAdvance = 0;
+    let prevCode = -1;
+    const chars = Array.from(text);
+    for (const char of chars) {
+      if (char === "\n") {
+        maxAdvance = Math.max(maxAdvance, penX - x);
+        penX = x;
+        line++;
+        prevCode = -1;
+        continue;
+      }
+      const code = char.codePointAt(0);
+      const def = this.byCode.get(code);
+      if (!def) {
+        prevCode = -1;
+        continue;
+      }
+      if (prevCode >= 0) {
+        const k = this.kern.get(kernKey(prevCode, code));
+        if (k) penX += k * fontSizePx;
+      }
+      const baseline = y + (ascender + line * lineHeight) * fontSizePx;
+      const pb = def.planeBounds;
+      const ab = def.atlasBounds;
+      if (pb && ab) {
+        const v0 = yOrigin === "bottom" ? 1 - ab.top / ah : ab.top / ah;
+        const v1 = yOrigin === "bottom" ? 1 - ab.bottom / ah : ab.bottom / ah;
+        glyphs.push({
+          char,
+          x: penX + pb.left * fontSizePx,
+          y: baseline - pb.top * fontSizePx,
+          w: (pb.right - pb.left) * fontSizePx,
+          h: (pb.top - pb.bottom) * fontSizePx,
+          u0: ab.left / aw,
+          v0,
+          u1: ab.right / aw,
+          v1
+        });
+      }
+      penX += def.advance * fontSizePx + letterSpacing;
+      prevCode = code;
+    }
+    maxAdvance = Math.max(maxAdvance, penX - x);
+    return {
+      glyphs,
+      width: maxAdvance,
+      height: (line + 1) * lineHeight * fontSizePx
+    };
+  }
+}, _class3.__initStatic(), _class3);
+
+// src/text/MSDFTextEntity.ts
+var MSDFTextEntity = (_class4 = class extends Entity {
+  
+  
+  
+  
+  
+  
+  
+  __init24() {this.text = ""}
+  __init25() {this.lastRenderedSeqId = 0}
+  __init26() {this.rgbColorCache = /* @__PURE__ */ new Map()}
+  __init27() {this.fontStringCache = []}
+  __init28() {this.layoutResult = null}
+  constructor(text, options) {
+    super();_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);;
+    this.font = options.font;
+    this.texture = options.texture;
+    this.fallbackFont = _nullishCoalesce(options.fallbackFont, () => ( "sans-serif"));
+    this.fontSize = _nullishCoalesce(options.fontSize, () => ( 32));
+    this.color = _nullishCoalesce(options.color, () => ( "#ffffff"));
+    this.letterSpacing = _nullishCoalesce(options.letterSpacing, () => ( 0));
+    this.lineHeight = options.lineHeight;
+    this.setText(text);
+  }
+  setText(text) {
+    if (this.text === text && this.layoutResult) return;
+    this.text = text;
+    _chunkRW6NC4RBjs.LayoutWorkerManager.getInstance().queueLayout(this.id, this.text, {
+      fontId: this.font.id,
+      fontSize: this.fontSize,
+      maxWidth: 1e3,
+      // standard wrap boundary
+      maxHeight: 1e3,
+      fontData: this.font.data,
+      letterSpacing: this.letterSpacing,
+      lineHeight: this.lineHeight,
+      callback: (res) => {
+        if (res.seqId < this.lastRenderedSeqId) return;
+        this.lastRenderedSeqId = res.seqId;
+        this.layoutResult = res;
+        _optionalChain([this, 'access', _18 => _18.scene, 'optionalAccess', _19 => _19.markDirty, 'call', _20 => _20()]);
+      }
+    });
+  }
+  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;
+  }
+  render(renderer) {
+    if (!this.layoutResult) return;
+    const scene = this.scene;
+    if (scene && scene.pointRenderer && scene.glCanvas) {
+      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 len2 = this.layoutResult.codePoints.length;
+      for (let i = 0; i < len2; i++) {
+        const code = this.layoutResult.codePoints[i];
+        const nodeX = this.layoutResult.xCoords[i];
+        const nodeY = this.layoutResult.yCoords[i];
+        const packedStyle = this.layoutResult.packedStyles[i];
+        const def = this.font.getGlyph(code);
+        if (!def || !def.atlasBounds || !def.planeBounds) continue;
+        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 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;
+        let runColor = this.rgbColorCache.get(colorVal);
+        if (!runColor) {
+          const r = colorVal >> 16 & 255;
+          const g = colorVal >> 8 & 255;
+          const b = colorVal & 255;
+          runColor = `rgb(${r},${g},${b})`;
+          this.rgbColorCache.set(colorVal, runColor);
+        }
+        scene.pointRenderer.addGlyph(
+          glyphX,
+          glyphY,
+          glyphW,
+          glyphH,
+          ab.left / aw,
+          v0,
+          ab.right / aw,
+          v1,
+          runColor,
+          this.opacity,
+          worldRot
+        );
+      }
+      return;
+    }
+    if (this.fontStringCache.length === 0) {
+      this.fontStringCache[0] = `${this.fontSize}px ${this.fallbackFont}`;
+      this.fontStringCache[1] = `bold ${this.fontSize}px ${this.fallbackFont}`;
+      this.fontStringCache[2] = `italic ${this.fontSize}px ${this.fallbackFont}`;
+      this.fontStringCache[3] = `italic bold ${this.fontSize}px ${this.fallbackFont}`;
+    }
+    const len = this.layoutResult.codePoints.length;
+    for (let i = 0; i < len; i++) {
+      const code = this.layoutResult.codePoints[i];
+      const nodeX = this.layoutResult.xCoords[i];
+      const nodeY = this.layoutResult.yCoords[i];
+      const packedStyle = this.layoutResult.packedStyles[i];
+      const fontString = this.fontStringCache[packedStyle & 3];
+      const colorVal = packedStyle >>> 8;
+      let runColor = this.rgbColorCache.get(colorVal);
+      if (!runColor) {
+        const r = colorVal >> 16 & 255;
+        const g = colorVal >> 8 & 255;
+        const b = colorVal & 255;
+        runColor = `rgb(${r},${g},${b})`;
+        this.rgbColorCache.set(colorVal, runColor);
+      }
+      renderer.fillText(String.fromCodePoint(code), nodeX, nodeY, fontString, runColor);
+    }
+  }
+  destroy() {
+    _chunkRW6NC4RBjs.LayoutWorkerManager.getInstance().cancelLayout(this.id);
+    super.destroy();
+  }
+}, _class4);
+
+// src/text/SVGEntity.ts
+var SVGEntity = (_class5 = class extends Entity {
+  __init29() {this.svgSource = ""}
+  __init30() {this.imageBitmap = null}
+  __init31() {this.imageElement = null}
+  __init32() {this.blobURL = null}
+  __init33() {this.currentImg = null}
+  __init34() {this.lodTimeout = null}
+  __init35() {this.cachedDoc = null}
+  __init36() {this.baseWidth = 100}
+  __init37() {this.baseHeight = 100}
+  __init38() {this.lastRasterizedScale = 1}
+  __init39() {this.targetScale = 1}
+  constructor(svgSource, id) {
+    super(id);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);;
+    this.setSVGSource(svgSource);
+  }
+  setSVGSource(svgSource) {
+    if (this.svgSource === svgSource) return;
+    this.svgSource = svgSource;
+    this.cachedDoc = null;
+    this.parseSVGDimensions();
+    this.triggerRasterization(this.lastRasterizedScale);
+  }
+  parseSVGDimensions() {
+    let width = 100;
+    let height = 100;
+    if (typeof window !== "undefined" && typeof DOMParser !== "undefined") {
+      try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(this.svgSource, "image/svg+xml");
+        const parserError = doc.querySelector("parsererror");
+        if (parserError) {
+          console.error("SVG Parsing error:", parserError.textContent);
+        } else {
+          this.cachedDoc = doc;
+          const svgEl = doc.documentElement;
+          const wAttr = svgEl.getAttribute("width");
+          const hAttr = svgEl.getAttribute("height");
+          const vbAttr = svgEl.getAttribute("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];
+            }
+          }
+        }
+      } catch (e) {
+        console.error("Failed parsing SVG via DOMParser, falling back to regex:", 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);
+        if (parts.length === 4) {
+          width = parts[2];
+          height = parts[3];
+        }
+      }
+    }
+    this.baseWidth = width;
+    this.baseHeight = height;
+    this.width = width;
+    this.height = height;
+  }
+  triggerRasterization(scale) {
+    if (typeof window === "undefined" || typeof Blob === "undefined") return;
+    if (this.currentImg) {
+      this.currentImg.onload = null;
+      this.currentImg.onerror = null;
+      this.currentImg = null;
+    }
+    if (this.blobURL) {
+      URL.revokeObjectURL(this.blobURL);
+      this.blobURL = null;
+    }
+    let processedSource = this.svgSource;
+    try {
+      let doc = this.cachedDoc;
+      if (!doc) {
+        const parser = new DOMParser();
+        doc = parser.parseFromString(this.svgSource, "image/svg+xml");
+        this.cachedDoc = doc;
+      }
+      const parserError = doc.querySelector("parsererror");
+      if (parserError) {
+        console.error(
+          "SVG Parsing validation error in triggerRasterization:",
+          parserError.textContent
+        );
+      } else {
+        const clonedDoc = doc.cloneNode(true);
+        const svgEl = clonedDoc.documentElement;
+        if (svgEl.tagName.toLowerCase() === "svg") {
+          const targetWidth = Math.max(1, Math.round(this.baseWidth * scale));
+          const targetHeight = Math.max(1, Math.round(this.baseHeight * scale));
+          svgEl.setAttribute("width", `${targetWidth}`);
+          svgEl.setAttribute("height", `${targetHeight}`);
+          if (!svgEl.hasAttribute("viewBox")) {
+            svgEl.setAttribute("viewBox", `0 0 ${this.baseWidth} ${this.baseHeight}`);
+          }
+          const serializer = new XMLSerializer();
+          processedSource = serializer.serializeToString(clonedDoc);
+        }
+      }
+    } catch (e) {
+      console.error("Failed to apply LOD scaling to SVG XML:", e);
+    }
+    const blob = new Blob([processedSource], { type: "image/svg+xml;charset=utf-8" });
+    this.blobURL = URL.createObjectURL(blob);
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    this.currentImg = img;
+    img.onload = () => {
+      if (this.currentImg !== img) return;
+      this.imageElement = img;
+      if (typeof createImageBitmap === "undefined") {
+        this.currentImg = null;
+        if (this.scene) this.scene.markDirty();
+        return;
+      }
+      createImageBitmap(img).then((bitmap) => {
+        if (this.currentImg !== img) {
+          bitmap.close();
+          return;
+        }
+        if (this.imageBitmap) {
+          this.imageBitmap.close();
+        }
+        this.imageBitmap = bitmap;
+        this.currentImg = null;
+        if (this.scene) this.scene.markDirty();
+      }).catch((e) => {
+        console.error("Failed to create ImageBitmap from SVG:", e);
+        this.currentImg = null;
+      });
+    };
+    img.onerror = (e) => {
+      if (this.currentImg !== img) return;
+      console.error("Failed to load SVG Image element:", e);
+      this.currentImg = null;
+    };
+    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;
+  }
+  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);
+      return;
+    }
+    const scale = this.getWorldScale();
+    const currentScale = Math.max(0.1, Math.max(scale.x, scale.y));
+    if (Math.abs(currentScale - this.lastRasterizedScale) / this.lastRasterizedScale > 0.2) {
+      this.targetScale = currentScale;
+      if (this.lodTimeout) clearTimeout(this.lodTimeout);
+      this.lodTimeout = setTimeout(() => {
+        this.triggerRasterization(this.targetScale);
+        this.lastRasterizedScale = this.targetScale;
+        this.lodTimeout = null;
+      }, 200);
+    }
+    if (this.imageBitmap) {
+      r.drawImage(this.imageBitmap, 0, 0, this.width, this.height);
+    } else if (this.imageElement) {
+      r.drawImage(this.imageElement, 0, 0, this.width, this.height);
+    }
+  }
+  destroy() {
+    if (this.lodTimeout) {
+      clearTimeout(this.lodTimeout);
+      this.lodTimeout = null;
+    }
+    if (this.currentImg) {
+      this.currentImg.onload = null;
+      this.currentImg.onerror = null;
+      this.currentImg = null;
+    }
+    if (this.imageBitmap) {
+      this.imageBitmap.close();
+      this.imageBitmap = null;
+    }
+    if (this.blobURL) {
+      URL.revokeObjectURL(this.blobURL);
+      this.blobURL = null;
+    }
+    this.imageElement = null;
+    this.cachedDoc = null;
+    super.destroy();
+  }
+}, _class5);
+
+
+
+
+
+
+
+exports.VectoJSEvent = VectoJSEvent; exports.Entity = Entity; exports.MSDFFont = MSDFFont; exports.MSDFTextEntity = MSDFTextEntity; exports.SVGEntity = SVGEntity;