@vectojs/core 1.28.1 → 1.30.0

package/dist/{chunk-K2UGEIT6.js → chunk-M73XB4ZK.js}

@@ -88,6 +88,12 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
    * change at runtime (e.g. a window dragged between displays).
    */
   
+  /**
+   * The ratio the context is actually scaled by, i.e. the last value the
+   * constructor or {@link resize} applied. Backs {@link pixelRatio}; see there
+   * for why this is recorded rather than recomputed on read.
+   */
+  __init3() {this.appliedDPR = 1}
   /**
    * Max circles per batched `fill()`. A single Canvas 2D `fill()` over a path is
    * superlinear in sub-path count, so an unbounded batch is *slower* than many
@@ -97,23 +103,23 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
   static __initStatic() {this.MAX_BATCH = 64}
   // Order-preserving batch state for fillCircle(): a run of same-style circles
   // accumulates into one path and is committed by a single fill() on flush().
-  __init3() {this.batchActive = false}
-  __init4() {this.batchColor = ""}
-  __init5() {this.batchAlpha = 1}
-  __init6() {this.batchCount = 0}
-  __init7() {this._cachedFont = ""}
-  __init8() {this._cachedFill = ""}
+  __init4() {this.batchActive = false}
+  __init5() {this.batchColor = ""}
+  __init6() {this.batchAlpha = 1}
+  __init7() {this.batchCount = 0}
+  __init8() {this._cachedFont = ""}
+  __init9() {this._cachedFill = ""}
   /** Backend discriminator; see {@link IRenderer.kind}. */
-  __init9() {this.kind = "canvas2d"}
+  __init10() {this.kind = "canvas2d"}
   /**
    * Draw counters, allocated only once counting is enabled.
    *
    * Null when off, so the guard on every op is a single null test and an inactive
    * renderer carries no counter object at all.
    */
-  __init10() {this.counters = null}
+  __init11() {this.counters = null}
   /** Accumulated primitive area, kept separately so the ratio is derived on read. */
-  __init11() {this.drawnArea = 0}
+  __init12() {this.drawnArea = 0}
   /**
    * @param canvas - The target canvas. Its backing store is resized to the
    *   logical size × devicePixelRatio.
@@ -123,9 +129,10 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
    *   set) so the canvas's own dimensions aren't clobbered by the window's.
    * @param maxDPR - See {@link maxDPR}.
    */
-  constructor(canvas, size, maxDPR) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);
+  constructor(canvas, size, maxDPR) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);
     this.maxDPR = maxDPR;
     const dpr = this.effectiveDPR();
+    this.appliedDPR = dpr;
     this.width = _nullishCoalesce(_optionalChain([size, 'optionalAccess', _5 => _5.width]), () => ( (typeof window !== "undefined" ? window.innerWidth : canvas.width || 0)));
     this.height = _nullishCoalesce(_optionalChain([size, 'optionalAccess', _6 => _6.height]), () => ( (typeof window !== "undefined" ? window.innerHeight : canvas.height || 0)));
     canvas.width = this.width * dpr;
@@ -164,7 +171,9 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
       if (!ctx) return;
       this.ctx = ctx;
       ctx.setTransform(1, 0, 0, 1, 0, 0);
-      ctx.scale(this.effectiveDPR(), this.effectiveDPR());
+      const restoredDPR = this.effectiveDPR();
+      this.appliedDPR = restoredDPR;
+      ctx.scale(restoredDPR, restoredDPR);
       this._cachedFont = "";
       this._cachedFill = "";
       this.batchActive = false;
@@ -187,6 +196,25 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
     const real = getDevicePixelRatio();
     return this.maxDPR !== void 0 ? Math.min(real, this.maxDPR) : real;
   }
+  /**
+   * @inheritdoc
+   *
+   * The ratio the context is **currently scaled by**, recorded by the constructor
+   * and {@link resize} — deliberately not a live `effectiveDPR()` call.
+   *
+   * The distinction is load-bearing rather than pedantic. `devicePixelRatio`
+   * changes the instant a zoom lands, but the backing store is only reallocated
+   * when something calls {@link resize} (in a `Scene`, the `(resolution: Ndppx)`
+   * media query). A live getter therefore reports the *future* ratio during that
+   * window, and a caller rasterizing pixels from it produces a texture that the
+   * still-old context scale resamples — the same defect this property exists to
+   * let callers avoid, merely inverted. Reporting the applied ratio means a
+   * cache keyed on it is always consistent with the pixels it is blitted into,
+   * and it simply re-keys on the next `resize`.
+   */
+  get pixelRatio() {
+    return this.appliedDPR;
+  }
   /**
    * Resize the backing canvas buffer and re-apply DPR scaling.
    *
@@ -197,6 +225,7 @@ var CanvasRenderer = (_class = class _CanvasRenderer {
    */
   resize(width, height) {
     const dpr = this.effectiveDPR();
+    this.appliedDPR = dpr;
     this.width = width;
     this.height = height;
     this.ctx.canvas.width = width * dpr;
@@ -501,42 +530,42 @@ function fontFamilyFromShorthand(font, sizeToken) {
 }
 var SVGRenderer = (_class2 = class {
   /** Backend discriminator; see {@link IRenderer.kind}. */
-  __init12() {this.kind = "svg"}
+  __init13() {this.kind = "svg"}
   
   
-  __init13() {this.buffer = []}
-  __init14() {this.defsBuffer = []}
-  __init15() {this.currentPath = []}
+  __init14() {this.buffer = []}
+  __init15() {this.defsBuffer = []}
+  __init16() {this.currentPath = []}
   // Inline matrix states (3x3 representation)
   // [a, b, c, d, e, f] corresponding to:
   // | a c e |
   // | b d f |
   // | 0 0 1 |
-  __init16() {this.mStack = []}
-  __init17() {this.ma = 1}
-  __init18() {this.mb = 0}
-  __init19() {this.mc = 0}
-  __init20() {this.md = 1}
-  __init21() {this.me = 0}
-  __init22() {this.mf = 0}
+  __init17() {this.mStack = []}
+  __init18() {this.ma = 1}
+  __init19() {this.mb = 0}
+  __init20() {this.mc = 0}
+  __init21() {this.md = 1}
+  __init22() {this.me = 0}
+  __init23() {this.mf = 0}
   // Alpha stack
-  __init23() {this.alphaStack = []}
-  __init24() {this.globalAlpha = 1}
+  __init24() {this.alphaStack = []}
+  __init25() {this.globalAlpha = 1}
   // Clipping stack
-  __init25() {this.clipDepthStack = []}
-  __init26() {this.clipDepth = 0}
-  __init27() {this.clipCounter = 0}
+  __init26() {this.clipDepthStack = []}
+  __init27() {this.clipDepth = 0}
+  __init28() {this.clipCounter = 0}
   // uniquely identifies clipPaths
   // Batch circles states (local coordinates)
-  __init28() {this.batchCircles = []}
-  __init29() {this.batchMatrix = [1, 0, 0, 1, 0, 0]}
-  __init30() {this.batchColor = ""}
-  __init31() {this.batchAlpha = 1}
-  __init32() {this.batchActive = false}
+  __init29() {this.batchCircles = []}
+  __init30() {this.batchMatrix = [1, 0, 0, 1, 0, 0]}
+  __init31() {this.batchColor = ""}
+  __init32() {this.batchAlpha = 1}
+  __init33() {this.batchActive = false}
   // Cache for generated gradient defs
-  __init33() {this.gradientCounter = 0}
-  __init34() {this.gradientCache = /* @__PURE__ */ new Map()}
-  constructor(width, height) {;_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);_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);_class2.prototype.__init25.call(this);_class2.prototype.__init26.call(this);_class2.prototype.__init27.call(this);_class2.prototype.__init28.call(this);_class2.prototype.__init29.call(this);_class2.prototype.__init30.call(this);_class2.prototype.__init31.call(this);_class2.prototype.__init32.call(this);_class2.prototype.__init33.call(this);_class2.prototype.__init34.call(this);
+  __init34() {this.gradientCounter = 0}
+  __init35() {this.gradientCache = /* @__PURE__ */ new Map()}
+  constructor(width, height) {;_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);_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);_class2.prototype.__init25.call(this);_class2.prototype.__init26.call(this);_class2.prototype.__init27.call(this);_class2.prototype.__init28.call(this);_class2.prototype.__init29.call(this);_class2.prototype.__init30.call(this);_class2.prototype.__init31.call(this);_class2.prototype.__init32.call(this);_class2.prototype.__init33.call(this);_class2.prototype.__init34.call(this);_class2.prototype.__init35.call(this);
     this.width = width;
     this.height = height;
     installRendererDevTraps(this, "SVGRenderer");
@@ -1908,11 +1937,11 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 `;
 var WebGPUParticleSystemManager = (_class3 = class {
   
-  __init35() {this.computePipeline = null}
-  __init36() {this.renderPipeline = null}
-  __init37() {this.computeBindGroupLayout = null}
-  __init38() {this.renderBindGroupLayout = null}
-  constructor(device) {;_class3.prototype.__init35.call(this);_class3.prototype.__init36.call(this);_class3.prototype.__init37.call(this);_class3.prototype.__init38.call(this);
+  __init36() {this.computePipeline = null}
+  __init37() {this.renderPipeline = null}
+  __init38() {this.computeBindGroupLayout = null}
+  __init39() {this.renderBindGroupLayout = null}
+  constructor(device) {;_class3.prototype.__init36.call(this);_class3.prototype.__init37.call(this);_class3.prototype.__init38.call(this);_class3.prototype.__init39.call(this);
     this.device = device;
   }
   initPipelines(format) {
@@ -2057,26 +2086,40 @@ var WebGPUParticleSystemManager = (_class3 = class {
 var HARD_MAX_SIZE = 8192;
 var PAD = 2;
 var GlyphRasterAtlas = (_class4 = class {
-  __init39() {this.slots = /* @__PURE__ */ new Map()}
+  __init40() {this.slots = /* @__PURE__ */ new Map()}
   
   
-  __init40() {this.canvas = null}
-  __init41() {this.ctx = null}
+  __init41() {this.canvas = null}
+  __init42() {this.ctx = null}
   /**
    * Shelf packing: glyphs land left-to-right on a row, then a new row starts.
    * A monospace grid produces near-uniform widths, so shelves waste very little
    * and cost one comparison per insert — a real 2D packer would buy nothing here.
    */
-  __init42() {this.penX = PAD}
-  __init43() {this.penY = PAD}
-  __init44() {this.rowHeight = 0}
-  __init45() {this._hits = 0}
-  __init46() {this._misses = 0}
-  __init47() {this._resets = 0}
-  constructor(options = {}) {;_class4.prototype.__init39.call(this);_class4.prototype.__init40.call(this);_class4.prototype.__init41.call(this);_class4.prototype.__init42.call(this);_class4.prototype.__init43.call(this);_class4.prototype.__init44.call(this);_class4.prototype.__init45.call(this);_class4.prototype.__init46.call(this);_class4.prototype.__init47.call(this);
+  __init43() {this.penX = PAD}
+  __init44() {this.penY = PAD}
+  __init45() {this.rowHeight = 0}
+  __init46() {this._hits = 0}
+  __init47() {this._misses = 0}
+  __init48() {this._resets = 0}
+  constructor(options = {}) {;_class4.prototype.__init40.call(this);_class4.prototype.__init41.call(this);_class4.prototype.__init42.call(this);_class4.prototype.__init43.call(this);_class4.prototype.__init44.call(this);_class4.prototype.__init45.call(this);_class4.prototype.__init46.call(this);_class4.prototype.__init47.call(this);_class4.prototype.__init48.call(this);
     this.dpr = Math.max(1, _nullishCoalesce(options.dpr, () => ( 1)));
     this.maxSize = Math.min(HARD_MAX_SIZE, Math.max(256, _nullishCoalesce(options.maxSize, () => ( 2048))));
   }
+  /**
+   * The device-pixel-ratio these slots were rasterized at.
+   *
+   * Immutable by design. Slot `sx`/`sy`/`sw`/`sh` are device pixels at *this*
+   * ratio while `w`/`h` are CSS pixels, so changing it would invalidate every
+   * resident slot — an atlas is therefore keyed by DPR and replaced on a change,
+   * not mutated (see `Markdown`'s code atlas pool). Exposed so a caller can
+   * compare it against {@link IRenderer.pixelRatio} and assert the blit is
+   * 1:1 rather than resampled: `blitScale = renderer.pixelRatio / atlas.dpr`,
+   * which must be 1 for the pixels to land crisp.
+   */
+  get pixelRatio() {
+    return this.dpr;
+  }
   /** Live instrumentation snapshot. */
   get stats() {
     return {
@@ -2241,13 +2284,13 @@ var GlyphRasterAtlas = (_class4 = class {
 
 // src/renderer/TextRasterCache.ts
 var TextRasterCache = (_class5 = class {
-  __init48() {this.cache = /* @__PURE__ */ new Map()}
+  __init49() {this.cache = /* @__PURE__ */ new Map()}
   
   
-  __init49() {this.scratchCtx = null}
-  __init50() {this._hits = 0}
-  __init51() {this._misses = 0}
-  constructor(options = {}) {;_class5.prototype.__init48.call(this);_class5.prototype.__init49.call(this);_class5.prototype.__init50.call(this);_class5.prototype.__init51.call(this);
+  __init50() {this.scratchCtx = null}
+  __init51() {this._hits = 0}
+  __init52() {this._misses = 0}
+  constructor(options = {}) {;_class5.prototype.__init49.call(this);_class5.prototype.__init50.call(this);_class5.prototype.__init51.call(this);_class5.prototype.__init52.call(this);
     this.maxEntries = Math.max(1, _nullishCoalesce(options.maxEntries, () => ( 4096)));
     this.dpr = Math.max(1, _nullishCoalesce(options.dpr, () => ( 1)));
   }