@solidtv/renderer 1.2.10 → 1.3.0

package/src/core/CoreTextNode.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { CoreTextNode, type CoreTextNodeProps } from './CoreTextNode.js';
+import { Stage } from './Stage.js';
+import { CoreRenderer } from './renderers/CoreRenderer.js';
+import { createBound } from './lib/utils.js';
+import type {
+  FontHandler,
+  TextRenderer,
+  TextRenderInfo,
+} from './text-rendering/TextRenderer.js';
+import type { Texture } from './textures/Texture.js';
+
+const defaultProps = (
+  overrides?: Partial<CoreTextNodeProps>,
+): CoreTextNodeProps => ({
+  // CoreNodeProps
+  alpha: 1,
+  autosize: false,
+  boundsMargin: null,
+  clipping: false,
+  color: 0xffffffff,
+  colorBl: 0xffffffff,
+  colorBottom: 0xffffffff,
+  colorBr: 0xffffffff,
+  colorLeft: 0xffffffff,
+  colorRight: 0xffffffff,
+  colorTl: 0xffffffff,
+  colorTop: 0xffffffff,
+  colorTr: 0xffffffff,
+  h: 0,
+  mount: 0,
+  mountX: 0,
+  mountY: 0,
+  parent: null,
+  pivot: 0,
+  pivotX: 0,
+  pivotY: 0,
+  rotation: 0,
+  rtt: false,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  shader: null,
+  src: '',
+  texture: null,
+  textureOptions: {} as never,
+  w: 0,
+  x: 0,
+  y: 0,
+  zIndex: 0,
+  preventDestroy: false,
+  // TrProps
+  text: '',
+  textAlign: 'left',
+  fontFamily: 'Ubuntu',
+  fontStyle: 'normal',
+  fontSize: 100,
+  maxWidth: 0,
+  maxHeight: 0,
+  offsetY: 0,
+  letterSpacing: 0,
+  lineHeight: 0,
+  maxLines: 0,
+  verticalAlign: 'top',
+  overflowSuffix: '...',
+  wordBreak: 'break-word',
+  contain: 'none',
+  // CoreTextNodeProps
+  textRendererOverride: null,
+  forceLoad: false,
+  ...overrides,
+});
+
+const makeStage = (texture: Texture) =>
+  mock<Stage>({
+    strictBound: createBound(0, 0, 200, 200),
+    preloadBound: createBound(0, 0, 200, 200),
+    defaultTexture: { state: 'loaded' } as never,
+    defShaderNode: null as never,
+    renderer: mock<CoreRenderer>() as CoreRenderer,
+    txManager: { createTexture: vi.fn(() => texture) } as never,
+  });
+
+const makeCanvasRenderer = (): TextRenderer => {
+  const font = mock<FontHandler>({ type: 'canvas' });
+  return {
+    type: 'canvas',
+    font,
+    renderText: vi.fn(),
+    addQuads: vi.fn(),
+    renderQuads: vi.fn(),
+    init: vi.fn(),
+  } as unknown as TextRenderer;
+};
+
+const makeLoadedTexture = () =>
+  ({
+    state: 'loaded',
+    dimensions: { w: 100, h: 50 },
+    retryCount: 0,
+    maxRetryCount: 0,
+    on: vi.fn(),
+    off: vi.fn(),
+    once: vi.fn(),
+    setRenderableOwner: vi.fn(),
+  } as unknown as Texture);
+
+describe('CoreTextNode (canvas) clearing text', () => {
+  it('clears the stale texture when text becomes empty', () => {
+    const renderer = makeCanvasRenderer();
+    const texture = makeLoadedTexture();
+    const stage = makeStage(texture);
+
+    const node = new CoreTextNode(
+      stage,
+      defaultProps({ text: 'Hello' }),
+      renderer,
+    );
+
+    // Simulate "Hello" having been rendered: canvas returns ImageData and a
+    // texture is created/assigned.
+    const helloResult: TextRenderInfo = {
+      imageData: {} as ImageData,
+      width: 100,
+      height: 50,
+    };
+    (
+      node as unknown as { handleRenderResult(r: TextRenderInfo): void }
+    ).handleRenderResult(helloResult);
+
+    expect(node.texture).toBe(texture);
+
+    // Now set text to empty. The canvas renderer returns no imageData.
+    const emptyResult: TextRenderInfo = { width: 0, height: 0 };
+    (
+      node as unknown as { handleRenderResult(r: TextRenderInfo): void }
+    ).handleRenderResult(emptyResult);
+
+    // The previously-rendered texture must be cleared so the old text does not
+    // linger and get re-marked renderable by CoreNode.updateIsRenderable.
+    expect(node.texture).toBe(null);
+    expect(node.isRenderable).toBe(false);
+  });
+});

package/src/core/CoreTextNode.ts

@@ -245,8 +245,10 @@ export class CoreTextNode extends CoreNode implements CoreTextNodeProps {
     // Handle Canvas renderer (uses ImageData)
     if (textRendererType === 'canvas') {
       if (result.imageData === undefined) {
-        // Empty text returns no imageData — mark not renderable and continue
+        // Empty text returns no imageData — clear the stale texture so the
+        // previous text doesn't linger, then mark not renderable and continue
         // to update dimensions (w=0, h=0) rather than emitting a failure.
+        this.texture = null;
         this.setRenderable(false);
       } else {
         this.texture = this.stage.txManager.createTexture('ImageTexture', {

package/src/core/CoreTextureManager.ts

@@ -10,6 +10,7 @@ import { EventEmitter } from '../common/EventEmitter.js';
 import type { Stage } from './Stage.js';
 import {
   validateCreateImageBitmap,
+  detectPremultiplyAlphaHonored,
   type CreateImageBitmapSupport,
 } from './lib/validateImageBitmap.js';
 import type { Platform } from './platforms/Platform.js';
@@ -46,6 +47,9 @@ export interface TextureManagerDebugInfo {
 export interface TextureManagerSettings {
   numImageWorkers: number;
   createImageBitmapSupport: 'auto' | 'basic' | 'options' | 'full';
+  // Override for whether createImageBitmap honors premultiplyAlpha:'premultiply'.
+  // 'auto' = detect via probe; boolean = force the value and skip the probe.
+  premultiplyAlphaHonored: boolean | 'auto';
   maxRetryCount: number;
 }
 
@@ -255,6 +259,7 @@ export class CoreTextureManager extends EventEmitter {
     basic: false,
     options: false,
     full: false,
+    premultiplyHonored: null as boolean | null,
   };
 
   hasWorker = !!self.Worker;
@@ -281,8 +286,12 @@ export class CoreTextureManager extends EventEmitter {
   constructor(stage: Stage, settings: TextureManagerSettings) {
     super();
 
-    const { numImageWorkers, createImageBitmapSupport, maxRetryCount } =
-      settings;
+    const {
+      numImageWorkers,
+      createImageBitmapSupport,
+      premultiplyAlphaHonored,
+      maxRetryCount,
+    } = settings;
 
     this.stage = stage;
     this.platform = stage.platform;
@@ -292,7 +301,7 @@ export class CoreTextureManager extends EventEmitter {
     if (createImageBitmapSupport === 'auto') {
       validateCreateImageBitmap(this.platform)
         .then((result) => {
-          this.initialize(result);
+          this.resolvePremultiplyAndInit(result, premultiplyAlphaHonored);
         })
         .catch(() => {
           console.warn(
@@ -304,11 +313,15 @@ export class CoreTextureManager extends EventEmitter {
           this.emit('initialized');
         });
     } else {
-      this.initialize({
-        basic: createImageBitmapSupport === 'basic',
-        options: createImageBitmapSupport === 'options',
-        full: createImageBitmapSupport === 'full',
-      });
+      this.resolvePremultiplyAndInit(
+        {
+          basic: createImageBitmapSupport === 'basic',
+          options: createImageBitmapSupport === 'options',
+          full: createImageBitmapSupport === 'full',
+          premultiplyHonored: null,
+        },
+        premultiplyAlphaHonored,
+      );
     }
 
     this.registerTextureType('ImageTexture', ImageTexture);
@@ -325,11 +338,51 @@ export class CoreTextureManager extends EventEmitter {
     this.txConstructors[textureType] = textureClass;
   }
 
+  /**
+   * Resolve `premultiplyHonored` on the support object, then initialize.
+   *
+   * - boolean override -> use it directly, skip the probe
+   * - 'auto' -> run the detection probe (only meaningful when the options/full
+   *   API exists, since that's the only path that passes the premultiply option)
+   */
+  private resolvePremultiplyAndInit(
+    support: CreateImageBitmapSupport,
+    premultiplyAlphaHonored: boolean | 'auto',
+  ): void {
+    if (premultiplyAlphaHonored !== 'auto') {
+      support.premultiplyHonored = premultiplyAlphaHonored;
+      this.initialize(support);
+      return;
+    }
+
+    if (support.options === false && support.full === false) {
+      support.premultiplyHonored = null;
+      this.initialize(support);
+      return;
+    }
+
+    detectPremultiplyAlphaHonored(this.platform)
+      .then((honored) => {
+        support.premultiplyHonored = honored;
+        this.initialize(support);
+      })
+      .catch(() => {
+        support.premultiplyHonored = null;
+        this.initialize(support);
+      });
+  }
+
   private initialize(support: CreateImageBitmapSupport) {
     this.hasCreateImageBitmap =
       support.basic || support.options || support.full;
     this.imageBitmapSupported = support;
 
+    if (support.premultiplyHonored === false) {
+      console.warn(
+        '[Lightning] createImageBitmap premultiplyAlpha:"premultiply" is not honored on this device — images may show alpha ghosting. GL-side premultiply fallback recommended.',
+      );
+    }
+
     if (this.hasCreateImageBitmap === false) {
       console.warn(
         '[Lightning] createImageBitmap is not supported on this browser. ImageTexture will be slower.',

package/src/core/Stage.ts

@@ -179,6 +179,7 @@ export class Stage {
       renderEngine,
       fontEngines,
       createImageBitmapSupport,
+      premultiplyAlphaHonored,
       platform,
       maxRetryCount,
     } = options;
@@ -206,6 +207,8 @@ export class Stage {
     this.txManager = new CoreTextureManager(this, {
       numImageWorkers,
       createImageBitmapSupport,
+      // undefined -> true (default: assume honored, no probe)
+      premultiplyAlphaHonored: premultiplyAlphaHonored ?? true,
       maxRetryCount,
     });
 

package/src/core/lib/ImageWorker.ts

@@ -43,12 +43,14 @@ function createImageWorker() {
     options: {
       supportsOptionsCreateImageBitmap: boolean;
       supportsFullCreateImageBitmap: boolean;
+      premultiplyAlphaHonored: boolean;
     },
   ): Promise<getImageReturn> {
     return new Promise(function (resolve, reject) {
       var supportsOptionsCreateImageBitmap =
         options.supportsOptionsCreateImageBitmap;
       var supportsFullCreateImageBitmap = options.supportsFullCreateImageBitmap;
+      var premultiplyAlphaHonored = options.premultiplyAlphaHonored;
       var xhr = new XMLHttpRequest();
       xhr.open('GET', src, true);
       xhr.responseType = 'blob';
@@ -71,6 +73,17 @@ function createImageWorker() {
             ? premultiplyAlpha
             : hasAlphaChannel(blob.type);
 
+        // When the device ignores the createImageBitmap premultiply option,
+        // create a straight ('none') bitmap and let WebGL premultiply on
+        // upload. `premultiplyAlpha` in the resolved value means "WebGL should
+        // premultiply this source on upload".
+        var useGlPremultiply =
+          withAlphaChannel === true && premultiplyAlphaHonored === false;
+        var bitmapMode: 'premultiply' | 'none' =
+          withAlphaChannel === true && useGlPremultiply === false
+            ? 'premultiply'
+            : 'none';
+
         // createImageBitmap with crop and options
         if (
           supportsFullCreateImageBitmap === true &&
@@ -78,12 +91,12 @@ function createImageWorker() {
           height !== null
         ) {
           createImageBitmap(blob, x || 0, y || 0, width, height, {
-            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
+            premultiplyAlpha: bitmapMode,
             colorSpaceConversion: 'none',
             imageOrientation: 'none',
           })
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: useGlPremultiply });
             })
             .catch(function (error) {
               reject(error);
@@ -94,22 +107,23 @@ function createImageWorker() {
           supportsFullCreateImageBitmap === false
         ) {
           // Fallback for browsers that do not support createImageBitmap with options
-          // this is supported for Chrome v50 to v52/54 that doesn't support options
+          // this is supported for Chrome v50 to v52/54 that doesn't support options.
+          // The browser default premultiplies, so WebGL must not premultiply again.
           createImageBitmap(blob)
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: false });
             })
             .catch(function (error) {
               reject(error);
             });
         } else {
           createImageBitmap(blob, {
-            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
+            premultiplyAlpha: bitmapMode,
             colorSpaceConversion: 'none',
             imageOrientation: 'none',
           })
             .then(function (data) {
-              resolve({ data: data, premultiplyAlpha: withAlphaChannel });
+              resolve({ data: data, premultiplyAlpha: useGlPremultiply });
             })
             .catch(function (error) {
               reject(error);
@@ -139,10 +153,13 @@ function createImageWorker() {
     // these will be set to true if the browser supports the createImageBitmap options or full
     var supportsOptionsCreateImageBitmap = false;
     var supportsFullCreateImageBitmap = false;
+    // set to false when the device is known to ignore the premultiply option
+    var premultiplyAlphaHonored = true;
 
     getImage(src, premultiplyAlpha, x, y, width, height, {
       supportsOptionsCreateImageBitmap,
       supportsFullCreateImageBitmap,
+      premultiplyAlphaHonored,
     })
       .then(function (data) {
         // @ts-ignore ts has wrong postMessage signature
@@ -240,6 +257,13 @@ export class ImageWorkerManager {
       );
     }
 
+    if (createImageBitmapSupport.premultiplyHonored === false) {
+      workerCode = workerCode.replace(
+        'var premultiplyAlphaHonored = true;',
+        'var premultiplyAlphaHonored = false;',
+      );
+    }
+
     workerCode = workerCode.replace('"use strict";', '');
     const blob: Blob = new Blob([workerCode], {
       type: 'application/javascript',

package/src/core/lib/textureSvg.ts

@@ -91,8 +91,11 @@ export const loadSvg = async (
     }
   }
 
+  // getImageData returns straight (un-premultiplied) pixels, so WebGL must
+  // premultiply this source on upload (unlike the ImageBitmap path above,
+  // where the canvas is already premultiplied by createImageBitmap's default).
   return {
     data: ctx.getImageData(0, 0, physW, physH),
-    premultiplyAlpha: false,
+    premultiplyAlpha: true,
   };
 };

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

@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { detectPremultiplyAlphaHonored } from './validateImageBitmap.js';
+import type { Platform } from '../platforms/Platform.js';
+
+/**
+ * Minimal stand-in for the WebGL constants/methods the probe touches. The probe
+ * uploads a known straight pixel, reads it back, and infers whether
+ * createImageBitmap premultiplied it. `readbackRed` is what readPixels returns
+ * for the red channel: ~128 = premultiplied (honored), ~255 = straight (ignored).
+ */
+function createFakeGl(readbackRed: number, framebufferComplete = true) {
+  return {
+    TEXTURE_2D: 0x0de1,
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241,
+    UNPACK_FLIP_Y_WEBGL: 0x9240,
+    RGBA: 0x1908,
+    UNSIGNED_BYTE: 0x1401,
+    FRAMEBUFFER: 0x8d40,
+    COLOR_ATTACHMENT0: 0x8ce0,
+    FRAMEBUFFER_COMPLETE: 0x8cd5,
+    createTexture: vi.fn(() => ({})),
+    bindTexture: vi.fn(),
+    pixelStorei: vi.fn(),
+    texImage2D: vi.fn(),
+    createFramebuffer: vi.fn(() => ({})),
+    bindFramebuffer: vi.fn(),
+    framebufferTexture2D: vi.fn(),
+    checkFramebufferStatus: vi.fn(() => (framebufferComplete ? 0x8cd5 : 0)),
+    readPixels: vi.fn(
+      (
+        _x: number,
+        _y: number,
+        _w: number,
+        _h: number,
+        _format: number,
+        _type: number,
+        px: Uint8Array,
+      ) => {
+        px[0] = readbackRed;
+        px[1] = 0;
+        px[2] = 0;
+        px[3] = 128;
+      },
+    ),
+    deleteFramebuffer: vi.fn(),
+    deleteTexture: vi.fn(),
+  };
+}
+
+function createPlatform(gl: object | null): Platform {
+  const close = vi.fn();
+  return {
+    createImageBitmap: vi.fn(() => Promise.resolve({ close })),
+    createCanvas: vi.fn(() => ({
+      width: 0,
+      height: 0,
+      getContext: vi.fn((type: string) => (type === 'webgl' ? gl : null)),
+    })),
+  } as unknown as Platform;
+}
+
+describe('detectPremultiplyAlphaHonored', () => {
+  beforeEach(() => {
+    // node test env has no ImageData global; the probe constructs one.
+    (globalThis as unknown as { ImageData: unknown }).ImageData = class {
+      data: Uint8ClampedArray;
+      width: number;
+      height: number;
+      constructor(data: Uint8ClampedArray, width: number, height: number) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
+      }
+    };
+  });
+
+  afterEach(() => {
+    delete (globalThis as unknown as { ImageData?: unknown }).ImageData;
+  });
+
+  it('returns true when the bitmap reads back premultiplied (~128)', async () => {
+    const platform = createPlatform(createFakeGl(128));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(true);
+  });
+
+  it('returns false when the bitmap reads back straight (~255)', async () => {
+    const platform = createPlatform(createFakeGl(255));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(false);
+  });
+
+  it('returns null when createImageBitmap throws', async () => {
+    const platform = {
+      createImageBitmap: vi.fn(() => Promise.reject(new Error('unsupported'))),
+      createCanvas: vi.fn(),
+    } as unknown as Platform;
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('returns null when no WebGL context is available', async () => {
+    const platform = createPlatform(null);
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('returns null when the framebuffer is incomplete', async () => {
+    const platform = createPlatform(createFakeGl(128, false));
+    expect(await detectPremultiplyAlphaHonored(platform)).toBe(null);
+  });
+
+  it('disables GL-side premultiply on the probe upload', async () => {
+    const gl = createFakeGl(128);
+    await detectPremultiplyAlphaHonored(createPlatform(gl));
+    // The probe must observe the bitmap's own alpha state, so GL premultiply
+    // has to be off during the readback upload.
+    expect(gl.pixelStorei).toHaveBeenCalledWith(
+      gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
+      false,
+    );
+  });
+});

package/src/core/lib/validateImageBitmap.ts

@@ -4,6 +4,11 @@ export interface CreateImageBitmapSupport {
   basic: boolean; // Supports createImageBitmap(image)
   options: boolean; // Supports createImageBitmap(image, options)
   full: boolean; // Supports createImageBitmap(image, sx, sy, sw, sh, options)
+  // Whether `premultiplyAlpha: 'premultiply'` is actually HONORED (not just
+  // accepted without throwing). null = could not determine. Older Safari/WebKit
+  // accepts the option but ignores it, returning straight alpha — the source of
+  // the edge-ghosting bug on those devices.
+  premultiplyHonored: boolean | null;
 }
 
 export async function validateCreateImageBitmap(
@@ -47,6 +52,7 @@ export async function validateCreateImageBitmap(
     basic: false,
     options: false,
     full: false,
+    premultiplyHonored: null,
   };
 
   // Test basic createImageBitmap support
@@ -83,5 +89,88 @@ export async function validateCreateImageBitmap(
     /* ignore */
   }
 
+  // premultiplyHonored is resolved separately by the caller (it may be a
+  // forced override or an explicit opt-in to the probe), so it is left as its
+  // default (null) here.
   return support;
 }
+
+/**
+ * Determine whether `createImageBitmap(..., { premultiplyAlpha: 'premultiply' })`
+ * is actually honored by this browser.
+ *
+ * Strategy: feed a known straight-alpha pixel (255, 0, 0, 128) through
+ * createImageBitmap with 'premultiply', upload it to a WebGL texture with
+ * GL-side premultiply DISABLED (so we observe the bitmap's own state), then
+ * read the raw texel back via a framebuffer.
+ *
+ *  - honored   -> red comes back premultiplied (~128)
+ *  - ignored   -> red comes back straight (~255)  [older Safari/WebKit]
+ *
+ * @returns true if honored, false if ignored, null if it couldn't be measured
+ * (no WebGL, createImageBitmap from ImageData unsupported, framebuffer
+ * incomplete, etc.) — caller should treat null as "unknown".
+ */
+export async function detectPremultiplyAlphaHonored(
+  platform: Platform,
+): Promise<boolean | null> {
+  let bitmap: ImageBitmap;
+  try {
+    // Straight (un-premultiplied) RGBA. ImageData is straight-alpha by spec.
+    const imageData = new ImageData(
+      new Uint8ClampedArray([255, 0, 0, 128]),
+      1,
+      1,
+    );
+    bitmap = await platform.createImageBitmap(imageData, {
+      premultiplyAlpha: 'premultiply',
+      colorSpaceConversion: 'none',
+      imageOrientation: 'none',
+    });
+  } catch (e) {
+    return null;
+  }
+
+  const canvas = platform.createCanvas();
+  canvas.width = 1;
+  canvas.height = 1;
+  const gl = (canvas.getContext('webgl') ||
+    canvas.getContext('experimental-webgl')) as WebGLRenderingContext | null;
+  if (gl === null) {
+    bitmap.close?.();
+    return null;
+  }
+
+  const tex = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  // Critical: do NOT let GL premultiply. We want to observe whatever state the
+  // bitmap itself is in.
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+
+  const fb = gl.createFramebuffer();
+  gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+  gl.framebufferTexture2D(
+    gl.FRAMEBUFFER,
+    gl.COLOR_ATTACHMENT0,
+    gl.TEXTURE_2D,
+    tex,
+    0,
+  );
+
+  let result: boolean | null = null;
+  if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE) {
+    const px = new Uint8Array(4);
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, px);
+    // Straight red reads ~255; premultiplied red reads ~128. Split at the
+    // midpoint to tolerate rounding/colorspace drift.
+    result = px[0]! < 192;
+  }
+
+  gl.deleteFramebuffer(fb);
+  gl.deleteTexture(tex);
+  bitmap.close?.();
+
+  return result;
+}

package/src/core/renderers/webgl/WebGlCtxTexture.ts

@@ -188,9 +188,13 @@ export class WebGlCtxTexture extends CoreContextTexture {
       w = tdata.width;
       h = tdata.height;
       glw.bindTexture(this._nativeCtxTexture);
+      // `premultiplyAlpha` carries the source's GL-upload intent: true when the
+      // source pixels are straight and WebGL must premultiply (e.g. a straight
+      // bitmap produced when the device ignores the createImageBitmap
+      // premultiply option), false when the source is already premultiplied.
       glw.pixelStorei(
         glw.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
-        isImageBitmap ? false : !!textureData.premultiplyAlpha,
+        !!textureData.premultiplyAlpha,
       );
 
       glw.texImage2D(0, format, format, glw.UNSIGNED_BYTE, tdata);