@solidtv/renderer 1.1.1 → 1.1.3

package/src/core/CoreNode.ts

@@ -761,10 +761,15 @@ export class CoreNode extends EventEmitter {
   protected _id: number = getNewId();
   readonly props: CoreNodeProps;
   public readonly isCoreNode = true as const;
+  /**
+   * Lazily allocated on first `animateProp` call. Animations are rare across
+   * the scene graph, so deferring the object literal avoids per-node GC
+   * pressure during construction.
+   */
   private _animations: Record<
     string,
     { controller: AnimationConfig; settings: Partial<AnimationSettings> }
-  > = {};
+  > | null = null;
 
   // WebGL Render Op State
   public renderOpBufferIdx: number = 0;
@@ -811,6 +816,28 @@ export class CoreNode extends EventEmitter {
   public isRenderable = false;
   public renderState: CoreNodeRenderState = CoreNodeRenderState.Init;
   public isSimple = true;
+  /**
+   * `true` when `localTransform` is in identity-shape (ta=1, tb=0, tc=0, td=1)
+   * — i.e. a pure translation. Lets the simple-path `updateLocalTransform`
+   * skip redundant ta/tb/tc/td writes between frames. Defaults to `true`
+   * because the matrix is eagerly allocated as an identity in the constructor.
+   */
+  public _localIsTranslate = true;
+  /**
+   * Cached result of the texture `contain` resizeMode check used by
+   * `updateLocalTransform` and `updateIsSimple`. Updated whenever the
+   * texture or textureOptions change (via `updateIsSimple`), so the hot
+   * paths can avoid the optional-chain + string compare on every frame.
+   */
+  public _hasContainResize = false;
+  /**
+   * `true` when `globalTransform` is in identity-shape (ta=1, tb=0, tc=0, td=1).
+   * Propagates from parent: a node's global is translate-only iff the parent's
+   * global is translate-only AND the node itself is `isSimple`. Default `true`
+   * because freshly-constructed nodes have no transform applied yet, and the
+   * Stage root is configured with an identity-shape global.
+   */
+  public _globalIsTranslate = true;
 
   public worldAlpha = 1;
   public premultipliedColorTl = 0;
@@ -835,6 +862,13 @@ export class CoreNode extends EventEmitter {
   constructor(readonly stage: Stage, props: CoreNodeProps) {
     super();
 
+    // Eagerly allocate the local/global transform matrices as identity.
+    // This keeps the field's hidden class monomorphic (Matrix3d, not
+    // Matrix3d|undefined) from construction onward and lets the simple
+    // / translate-only fast paths take effect on the very first update.
+    this.localTransform = Matrix3d.identity();
+    this.globalTransform = Matrix3d.identity();
+
     //inital update type
     let initialUpdateType =
       UpdateType.Local | UpdateType.RenderBounds | UpdateType.RenderState;
@@ -1089,7 +1123,18 @@ export class CoreNode extends EventEmitter {
     const { x, y } = p;
 
     if (this.isSimple) {
+      // Fast path: when localTransform is already in identity-shape
+      // (ta=1, tb=0, tc=0, td=1), only tx/ty change between frames, so we
+      // skip the 4 redundant field writes Matrix3d.translate would do.
+      // _localIsTranslate becomes stale when a node was non-simple (had
+      // rotation/scale/mount) on a previous frame — in that case do a
+      // full reset to identity-translate.
+      if (this._localIsTranslate === true) {
+        this.localTransform!.setTranslate(x, y);
+        return;
+      }
       this.localTransform = Matrix3d.translate(x, y, this.localTransform);
+      this._localIsTranslate = true;
       return;
     }
 
@@ -1097,10 +1142,15 @@ export class CoreNode extends EventEmitter {
     const mountTranslateX = p.mountX * w;
     const mountTranslateY = p.mountY * h;
 
-    if (p.rotation !== 0 || p.scaleX !== 1 || p.scaleY !== 1) {
-      const scaleRotate = Matrix3d.rotate(p.rotation, Matrix3d.temp).scale(
-        p.scaleX,
-        p.scaleY,
+    const rotation = p.rotation;
+    const scaleX = p.scaleX;
+    const scaleY = p.scaleY;
+
+    if (rotation !== 0) {
+      // Full rotation (+ optional scale + pivot)
+      const scaleRotate = Matrix3d.rotate(rotation, Matrix3d.temp).scale(
+        scaleX,
+        scaleY,
       );
       const pivotTranslateX = p.pivotX * w;
       const pivotTranslateY = p.pivotY * h;
@@ -1112,7 +1162,21 @@ export class CoreNode extends EventEmitter {
       )
         .multiply(scaleRotate)
         .translate(-pivotTranslateX, -pivotTranslateY);
+    } else if (scaleX !== 1 || scaleY !== 1) {
+      // Scale (+ optional pivot) without rotation — skip the rotate matrix
+      // and the 8-mul multiply; `.scale()` is a 4-mul in-place op.
+      const pivotTranslateX = p.pivotX * w;
+      const pivotTranslateY = p.pivotY * h;
+
+      this.localTransform = Matrix3d.translate(
+        x - mountTranslateX + pivotTranslateX,
+        y - mountTranslateY + pivotTranslateY,
+        this.localTransform,
+      )
+        .scale(scaleX, scaleY)
+        .translate(-pivotTranslateX, -pivotTranslateY);
     } else {
+      // Mount (or texture-contain) only — pure translation.
       this.localTransform = Matrix3d.translate(
         x - mountTranslateX,
         y - mountTranslateY,
@@ -1120,12 +1184,13 @@ export class CoreNode extends EventEmitter {
       );
     }
 
-    // Handle 'contain' resize mode
+    // Handle 'contain' resize mode (cached check; dimensions still need
+    // a runtime null-check because they're populated asynchronously).
     const texture = p.texture;
     if (
-      texture &&
-      texture.dimensions &&
-      p.textureOptions.resizeMode?.type === 'contain'
+      this._hasContainResize === true &&
+      texture !== null &&
+      texture.dimensions !== null
     ) {
       let resizeModeScaleX = 1;
       let resizeModeScaleY = 1;
@@ -1157,17 +1222,23 @@ export class CoreNode extends EventEmitter {
         .translate(extraX, extraY)
         .scale(resizeModeScaleX, resizeModeScaleY);
     }
+
+    this._localIsTranslate = false;
   }
 
   updateIsSimple() {
     const p = this.props;
+    // Cache the texture-contain check so updateLocalTransform doesn't have to
+    // run the optional-chain + string compare on every Local update.
+    this._hasContainResize =
+      p.texture !== null && p.textureOptions?.resizeMode?.type === 'contain';
     this.isSimple =
       p.rotation === 0 &&
       p.scaleX === 1 &&
       p.scaleY === 1 &&
       p.mountX === 0 &&
       p.mountY === 0 &&
-      !(p.texture && p.textureOptions.resizeMode?.type === 'contain');
+      this._hasContainResize === false;
   }
 
   /**
@@ -1209,6 +1280,10 @@ export class CoreNode extends EventEmitter {
     }
 
     if (updateType & UpdateType.Global) {
+      const lt = this.localTransform!;
+      const gt = this.globalTransform!;
+      let fastPathApplied = false;
+
       if (
         USE_RTT &&
         this.parentHasRenderTexture === true &&
@@ -1216,7 +1291,7 @@ export class CoreNode extends EventEmitter {
       ) {
         // we are at the start of the RTT chain, so we need to reset the globalTransform
         // for correct RTT rendering
-        this.globalTransform = Matrix3d.identity(this.globalTransform);
+        Matrix3d.identity(gt);
 
         // Maintain a full scene global transform for bounds detection
         const parentTransform =
@@ -1225,7 +1300,10 @@ export class CoreNode extends EventEmitter {
         this.sceneGlobalTransform = Matrix3d.copy(
           parentTransform,
           this.sceneGlobalTransform,
-        ).translateOrMultiply(this.localTransform!);
+        ).translateOrMultiply(lt);
+
+        // identity * local => translate-only iff this node is simple
+        this._globalIsTranslate = this.isSimple;
       } else if (
         USE_RTT &&
         this.parentHasRenderTexture === true &&
@@ -1234,32 +1312,48 @@ export class CoreNode extends EventEmitter {
         // we're part of an RTT chain but our parent is not the main RTT node
         // so we need to propogate the sceneGlobalTransform of the parent
         // to maintain a full scene global transform for bounds detection
-        const parentSceneTransform =
-          parent.sceneGlobalTransform || this.localTransform!;
+        const parentSceneTransform = parent.sceneGlobalTransform || lt;
 
         this.sceneGlobalTransform = Matrix3d.copy(
           parentSceneTransform,
           this.sceneGlobalTransform,
-        ).translateOrMultiply(this.localTransform!);
+        ).translateOrMultiply(lt);
 
-        this.globalTransform = Matrix3d.copy(
-          parent.globalTransform || this.localTransform!,
-          this.globalTransform,
-        );
+        Matrix3d.copy(parent.globalTransform!, gt);
+
+        // Conservative: RTT chains rarely hit the translate fast path
+        this._globalIsTranslate = false;
       } else {
-        this.globalTransform = Matrix3d.copy(
-          parent.globalTransform || this.localTransform!,
-          this.globalTransform,
-        );
+        // Common non-RTT path
+        const parentGT = parent.globalTransform!;
+        if (this.isSimple === true && parent._globalIsTranslate === true) {
+          // Translate-only fast path: parent global and local are both pure
+          // translations, so the resulting global is also a pure translation
+          // and collapses to 2 adds on tx/ty.
+          if (this._globalIsTranslate === false) {
+            // Transitioning back into translate-only — reset ta/tb/tc/td
+            // that may have been left non-identity by a prior frame.
+            gt.ta = 1;
+            gt.tb = 0;
+            gt.tc = 0;
+            gt.td = 1;
+          }
+          gt.setTranslate(parentGT.tx + lt.tx, parentGT.ty + lt.ty);
+          this._globalIsTranslate = true;
+          fastPathApplied = true;
+        } else {
+          Matrix3d.copy(parentGT, gt);
+          this._globalIsTranslate =
+            this.isSimple === true && parent._globalIsTranslate === true;
+        }
       }
 
-      if (this.isSimple) {
-        this.globalTransform.translate(
-          this.localTransform!.tx,
-          this.localTransform!.ty,
-        );
-      } else {
-        this.globalTransform.translateOrMultiply(this.localTransform!);
+      if (fastPathApplied === false) {
+        if (this.isSimple) {
+          gt.translate(lt.tx, lt.ty);
+        } else {
+          gt.translateOrMultiply(lt);
+        }
       }
       this.calculateRenderCoords();
       this.updateBoundingRect();
@@ -1380,18 +1474,30 @@ export class CoreNode extends EventEmitter {
         childClippingRect = NO_CLIPPING_RECT;
       }
 
-      for (let i = 0, length = this.children.length; i < length; i++) {
-        const child = this.children[i] as CoreNode;
-
-        if (childUpdateType !== 0) {
+      const children = this.children;
+      const length = children.length;
+      if (childUpdateType !== 0) {
+        // Specialized loop: OR-in the inherited update bits for every child,
+        // then update if non-zero. Avoids the per-iter `childUpdateType !== 0`
+        // compare.
+        for (let i = 0; i < length; i++) {
+          const child = children[i] as CoreNode;
           child.updateType |= childUpdateType;
+          if (child.updateType === 0) {
+            continue;
+          }
+          child.update(delta, childClippingRect);
         }
-
-        if (child.updateType === 0) {
-          continue;
+      } else {
+        // Specialized loop: nothing to inherit, so only walk children that
+        // already have pending work of their own.
+        for (let i = 0; i < length; i++) {
+          const child = children[i] as CoreNode;
+          if (child.updateType === 0) {
+            continue;
+          }
+          child.update(delta, childClippingRect);
         }
-
-        child.update(delta, childClippingRect);
       }
     }
 
@@ -1503,7 +1609,7 @@ export class CoreNode extends EventEmitter {
     const renderCoords = (this.sceneRenderCoords ||
       this.renderCoords) as RenderCoords;
 
-    if (transform.tb === 0 || transform.tc === 0) {
+    if (transform.tb === 0 && transform.tc === 0) {
       this.renderBound = createBound(
         renderCoords.x1,
         renderCoords.y1,
@@ -2835,27 +2941,32 @@ export class CoreNode extends EventEmitter {
     value: number,
     settings: Partial<AnimationSettings>,
   ): IAnimationController {
-    const existing = this._animations[name];
-
-    if (existing && existing.settings === settings) {
-      const controller = existing.controller;
-      const values = controller.props ? controller.props[name] : null;
-
-      if (values) {
-        values.start = (this as any)[name] ?? 0;
-        values.target = value;
-        controller.progress = 0;
-
-        if (settings.adaptiveDuration === true) {
-          const now = performance.now();
-          const elapsed = now - controller.lastRunTime;
-          controller.lastRunTime = now;
-          const duration = settings.duration ?? controller.duration;
-          controller.duration = elapsed < duration ? elapsed : duration;
-        }
+    let animations = this._animations;
+    if (animations !== null) {
+      const existing = animations[name];
+
+      if (existing && existing.settings === settings) {
+        const controller = existing.controller;
+        const values = controller.props ? controller.props[name] : null;
+
+        if (values) {
+          values.start = (this as any)[name] ?? 0;
+          values.target = value;
+          controller.progress = 0;
+
+          if (settings.adaptiveDuration === true) {
+            const now = performance.now();
+            const elapsed = now - controller.lastRunTime;
+            controller.lastRunTime = now;
+            const duration = settings.duration ?? controller.duration;
+            controller.duration = elapsed < duration ? elapsed : duration;
+          }
 
-        return controller.start();
+          return controller.start();
+        }
       }
+    } else {
+      animations = this._animations = {};
     }
 
     const animationProps: Partial<CoreNodeAnimateProps> = { [name]: value };
@@ -2865,12 +2976,16 @@ export class CoreNode extends EventEmitter {
       animationProps,
       settings,
     );
-    this._animations[name] = { controller, settings };
+    animations[name] = { controller, settings };
     return controller.start();
   }
 
   animateToTarget(prop: string): number | undefined {
-    const animation = this._animations[prop];
+    const animations = this._animations;
+    if (animations === null) {
+      return undefined;
+    }
+    const animation = animations[prop];
     if (!animation) {
       return undefined;
     }

package/src/core/CoreTextureManager.ts

@@ -159,16 +159,78 @@ export interface TextureOptions {
   resizeMode?: ResizeModeOptions;
 }
 
-export class CoreTextureManager extends EventEmitter {
+/**
+ * Insertion-ordered, dedup'd FIFO queue used by the texture upload
+ * pipeline.
+ *
+ * Backed by an array (for ordered traversal without per-call iterator
+ * allocation) plus a Set (for O(1) membership and cancel-by-reference).
+ * Removed entries are tombstoned in the array — they're skipped on the
+ * next `shift()`, and the array is compacted once the consumed prefix
+ * grows large enough to be worth reclaiming.
+ */
+class TextureUploadQueue {
+  private list: Texture[] = [];
+  private membership: Set<Texture> = new Set();
+  private head = 0;
+
+  get size(): number {
+    return this.membership.size;
+  }
+
+  has(texture: Texture): boolean {
+    return this.membership.has(texture);
+  }
+
+  add(texture: Texture): void {
+    if (this.membership.has(texture)) {
+      return;
+    }
+    this.membership.add(texture);
+    this.list.push(texture);
+  }
+
+  delete(texture: Texture): boolean {
+    return this.membership.delete(texture);
+  }
+
   /**
-   * Map of textures by cache key
+   * Remove and return the oldest live entry, or `undefined` if empty.
    */
-  keyCache: Map<string, Texture> = new Map();
+  shift(): Texture | undefined {
+    const list = this.list;
+    const membership = this.membership;
+    while (this.head < list.length) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const texture = list[this.head++]!;
+      if (membership.has(texture)) {
+        membership.delete(texture);
+        this.compactIfNeeded();
+        return texture;
+      }
+    }
+    // Fully drained — reset for the next batch.
+    this.head = 0;
+    list.length = 0;
+    return undefined;
+  }
+
+  private compactIfNeeded(): void {
+    // Drop the consumed prefix once it's substantial in absolute terms
+    // and at least half the array. Avoids growing the array unboundedly
+    // when shift() runs faster than the queue refills.
+    if (this.head >= 64 && this.head >= this.list.length >> 1) {
+      this.list = this.list.slice(this.head);
+      this.head = 0;
+    }
+  }
+}
 
+export class CoreTextureManager extends EventEmitter {
   /**
-   * Map of cache keys by texture
+   * Map of textures by cache key
    */
-  inverseKeyCache: WeakMap<Texture, string> = new WeakMap();
+  keyCache: Map<string, Texture> = new Map();
 
   /**
    * Map of texture constructors by their type name
@@ -176,7 +238,7 @@ export class CoreTextureManager extends EventEmitter {
   txConstructors: Partial<TextureMap> = {};
 
   public maxRetryCount: number;
-  private uploadTextureQueue: Set<Texture> = new Set();
+  private uploadTextureQueue: TextureUploadQueue = new TextureUploadQueue();
   private initialized = false;
   private stage: Stage;
   private numImageWorkers: number;
@@ -494,13 +556,9 @@ export class CoreTextureManager extends EventEmitter {
       texture.state === 'failed' || texture.state === 'freed';
 
     const fillPrefetch = () => {
-      while (
-        pending.length < prefetchLimit &&
-        this.uploadTextureQueue.size > 0
-      ) {
-        const [texture] = this.uploadTextureQueue;
-        if (!texture) break;
-        this.uploadTextureQueue.delete(texture);
+      while (pending.length < prefetchLimit) {
+        const texture = this.uploadTextureQueue.shift();
+        if (texture === undefined) break;
 
         if (isDead(texture)) {
           continue;
@@ -570,9 +628,8 @@ export class CoreTextureManager extends EventEmitter {
    * @param cacheKey Cache key for the texture
    */
   initTextureToCache(texture: Texture, cacheKey: string) {
-    const { keyCache, inverseKeyCache } = this;
-    keyCache.set(cacheKey, texture);
-    inverseKeyCache.set(texture, cacheKey);
+    this.keyCache.set(cacheKey, texture);
+    texture.cacheKey = cacheKey;
   }
 
   /**
@@ -593,10 +650,10 @@ export class CoreTextureManager extends EventEmitter {
    * @param texture
    */
   removeTextureFromCache(texture: Texture) {
-    const { inverseKeyCache, keyCache } = this;
-    const cacheKey = inverseKeyCache.get(texture);
-    if (cacheKey) {
-      keyCache.delete(cacheKey);
+    const cacheKey = texture.cacheKey;
+    if (cacheKey !== null) {
+      this.keyCache.delete(cacheKey);
+      texture.cacheKey = null;
     }
   }
 

package/src/core/Stage.ts

@@ -359,9 +359,10 @@ export class Stage {
 
     this.root = rootNode;
 
-    // Initialize root node properties
+    // Initialize root node properties. Copy in place into the eagerly-allocated
+    // matrices so the hidden class for these fields stays stable.
     rootNode.updateLocalTransform();
-    rootNode.globalTransform = Matrix3d.copy(rootNode.localTransform!);
+    Matrix3d.copy(rootNode.localTransform!, rootNode.globalTransform);
     rootNode.sceneGlobalTransform = Matrix3d.copy(rootNode.localTransform!);
     rootNode.calculateRenderCoords();
     rootNode.updateBoundingRect();
@@ -1066,7 +1067,7 @@ export class Stage {
    * @param options - Font loading options specific to the renderer type
    * @returns Promise that resolves when the font is loaded
    */
-  async loadFont(
+  loadFont(
     rendererType: TextRenderers,
     options: FontLoadOptions,
   ): Promise<void> {
@@ -1074,10 +1075,12 @@ export class Stage {
     const fontHandler = this.fontHandlers[rendererTypeKey];
 
     if (!fontHandler) {
-      throw new Error(
-        `Font handler for renderer type '${rendererTypeKey}' not found. Available types: ${Object.keys(
-          this.fontHandlers,
-        ).join(', ')}`,
+      return Promise.reject(
+        new Error(
+          `Font handler for renderer type '${rendererTypeKey}' not found. Available types: ${Object.keys(
+            this.fontHandlers,
+          ).join(', ')}`,
+        ),
       );
     }
 

package/src/core/lib/Matrix3d.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { Matrix3d } from './Matrix3d.js';
+
+describe('Matrix3d.setTranslate', () => {
+  it('writes tx/ty without touching ta/tb/tc/td', () => {
+    const m = Matrix3d.identity();
+    m.setTranslate(10, 20);
+    expect(m.tx).toBe(10);
+    expect(m.ty).toBe(20);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+  });
+
+  it('updates the float array on subsequent getFloatArr() calls', () => {
+    const m = Matrix3d.identity();
+    m.setTranslate(5, 7);
+    // First read populates the array
+    const arr = m.getFloatArr();
+    expect(arr[6]).toBe(5);
+    expect(arr[7]).toBe(7);
+
+    // Mutate, then expect getFloatArr() to pick up the change.
+    m.setTranslate(9, 11);
+    const arr2 = m.getFloatArr();
+    expect(arr2[6]).toBe(9);
+    expect(arr2[7]).toBe(11);
+    // Same array reference reused (no GC pressure).
+    expect(arr2).toBe(arr);
+  });
+
+  it('overwrites prior tx/ty values', () => {
+    const m = Matrix3d.translate(100, 200);
+    m.setTranslate(0, 0);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+});
+
+describe('Matrix3d.rotate(0) fast path', () => {
+  it('produces an identity matrix for angle=0', () => {
+    const m = Matrix3d.rotate(0);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+
+  it('resets a pre-populated out matrix to identity on angle=0', () => {
+    const m = Matrix3d.rotate(Math.PI / 4);
+    // Now reuse `m` with angle=0; should overwrite to identity.
+    Matrix3d.rotate(0, m);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+
+  it('still produces a real rotation when angle != 0', () => {
+    const m = Matrix3d.rotate(Math.PI / 2);
+    // cos(pi/2) ~ 0, sin(pi/2) = 1
+    expect(Math.abs(m.ta)).toBeLessThan(1e-10);
+    expect(m.tb).toBeCloseTo(-1, 10);
+    expect(m.tc).toBeCloseTo(1, 10);
+    expect(Math.abs(m.td)).toBeLessThan(1e-10);
+  });
+});

package/src/core/lib/Matrix3d.ts

@@ -124,11 +124,24 @@ export class Matrix3d {
   }
 
   public static rotate(angle: number, out?: Matrix3d): Matrix3d {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    if (!out) {
+    if (out === undefined) {
       out = new Matrix3d();
     }
+    if (angle === 0) {
+      // Skip Math.cos(0) / Math.sin(0) — neither V8 nor JSC constant-folds
+      // these calls. Identity rotation is the common case when callers
+      // combine rotate().scale() and only the scale is non-default.
+      out.ta = 1;
+      out.tb = 0;
+      out.tx = 0;
+      out.tc = 0;
+      out.td = 1;
+      out.ty = 0;
+      out.mutation = true;
+      return out;
+    }
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
     out.ta = cos;
     out.tb = -sin;
     out.tx = 0;
@@ -160,6 +173,20 @@ export class Matrix3d {
     return this;
   }
 
+  /**
+   * Writes `tx`/`ty` directly and marks the matrix mutated.
+   *
+   * Caller is responsible for ensuring `ta`/`tb`/`tc`/`td` are already the
+   * desired values — typically the identity rotation/scale (1, 0, 0, 1).
+   * Used by hot paths that know the matrix is in identity-shape so the
+   * 4 redundant field writes performed by `Matrix3d.translate` can be skipped.
+   */
+  public setTranslate(x: number, y: number): void {
+    this.tx = x;
+    this.ty = y;
+    this.mutation = true;
+  }
+
   public scale(sx: number, sy: number): Matrix3d {
     this.ta = this.ta * sx;
     this.tb = this.tb * sy;

package/src/core/lib/WebGlContextWrapper.ts

@@ -1,8 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-
-import { assertTruthy, isProductionEnvironment } from '../../utils.js';
 import type {
   Vec2,
   Vec3,