@sythos/js_barcode_universal 0.1.0

package/src/render/png.js

@@ -0,0 +1,295 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * PNG output, with no dependencies and no compression library of our own.
+ *
+ * A barcode is a two-colour image, so this writes a 1-bit palette PNG: eight
+ * modules per byte, and a two-entry palette. That is both the smallest and the
+ * simplest correct encoding.
+ *
+ * Compression strategy, in order of preference:
+ *
+ *   1. `node:zlib` in Node.
+ *   2. `CompressionStream('deflate')` in browsers that have it.
+ *   3. Stored (uncompressed) deflate blocks, written here.
+ *
+ * Writing a Huffman coder would be a week of work to save a few kilobytes on
+ * an image that is mostly already tiny. The stored-block fallback is about
+ * eighty lines and produces a completely valid PNG; the only cost is size, on
+ * the minority of platforms that reach it.
+ *
+ * @module render/png
+ */
+
+import { normalizeOptions, parseColor } from './options.js';
+
+/* ------------------------------------------------------------------ *
+ * Checksums
+ * ------------------------------------------------------------------ */
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {number}
+ */
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) {
+    c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+  }
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {number}
+ */
+function adler32(bytes) {
+  let a = 1;
+  let b = 0;
+  // 5552 is the largest run that cannot overflow the 32-bit accumulator.
+  for (let i = 0; i < bytes.length;) {
+    const end = Math.min(i + 5552, bytes.length);
+    for (; i < end; i++) {
+      a += bytes[i];
+      b += a;
+    }
+    a %= 65521;
+    b %= 65521;
+  }
+  return ((b << 16) | a) >>> 0;
+}
+
+/* ------------------------------------------------------------------ *
+ * Deflate
+ * ------------------------------------------------------------------ */
+
+/**
+ * Wrap data in stored (type 00) deflate blocks with a zlib header.
+ *
+ * A stored block's length field is sixteen bits, so each block caps at 65535
+ * bytes and longer data must be split. BFINAL is set on the last block only —
+ * getting that wrong yields a stream that decodes correctly for any small
+ * image and truncates on the first large one.
+ *
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+export function deflateStored(data) {
+  const MAX = 0xffff;
+  const blockCount = Math.max(1, Math.ceil(data.length / MAX));
+  const out = new Uint8Array(2 + blockCount * 5 + data.length + 4);
+  let p = 0;
+
+  // zlib header: deflate, 32K window, no preset dictionary. 0x78 0x01 is a
+  // valid FCHECK pair (0x7801 % 31 === 0).
+  out[p++] = 0x78;
+  out[p++] = 0x01;
+
+  for (let i = 0; i < blockCount; i++) {
+    const start = i * MAX;
+    const len = Math.min(MAX, data.length - start);
+    const isLast = i === blockCount - 1;
+
+    out[p++] = isLast ? 1 : 0;           // BFINAL, BTYPE = 00
+    out[p++] = len & 0xff;               // LEN, little endian
+    out[p++] = (len >>> 8) & 0xff;
+    out[p++] = ~len & 0xff;              // NLEN, one's complement
+    out[p++] = (~len >>> 8) & 0xff;
+
+    out.set(data.subarray(start, start + len), p);
+    p += len;
+  }
+
+  const sum = adler32(data);
+  out[p++] = (sum >>> 24) & 0xff;        // adler32, big endian
+  out[p++] = (sum >>> 16) & 0xff;
+  out[p++] = (sum >>> 8) & 0xff;
+  out[p++] = sum & 0xff;
+
+  return out.subarray(0, p);
+}
+
+/**
+ * Compress with whatever the platform provides, falling back to stored blocks.
+ *
+ * @param {Uint8Array} data
+ * @returns {Promise<Uint8Array>}
+ */
+async function deflate(data) {
+  // Node: zlib is built in, so this is not a dependency.
+  if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+    try {
+      const zlib = await import('node:zlib');
+      return new Uint8Array(zlib.deflateSync(data));
+    } catch {
+      /* fall through */
+    }
+  }
+
+  // Browsers: CompressionStream('deflate') emits the zlib format PNG wants.
+  if (typeof CompressionStream === 'function') {
+    try {
+      const stream = new Blob([data]).stream().pipeThrough(new CompressionStream('deflate'));
+      const buffer = await new Response(stream).arrayBuffer();
+      return new Uint8Array(buffer);
+    } catch {
+      /* fall through */
+    }
+  }
+
+  return deflateStored(data);
+}
+
+/* ------------------------------------------------------------------ *
+ * PNG assembly
+ * ------------------------------------------------------------------ */
+
+const SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+/**
+ * @param {string} type Four ASCII characters.
+ * @param {Uint8Array} payload
+ * @returns {Uint8Array}
+ */
+function chunk(type, payload) {
+  const out = new Uint8Array(12 + payload.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, payload.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(payload, 8);
+  // The CRC covers the type and the payload, but not the length.
+  view.setUint32(8 + payload.length, crc32(out.subarray(4, 8 + payload.length)));
+  return out;
+}
+
+/**
+ * Render to a PNG file.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {Promise<Uint8Array>}
+ */
+export async function toPNG(matrix, options = {}) {
+  const opts = normalizeOptions(matrix, options);
+  const { scale, source, pixelWidth, pixelHeight } = opts;
+
+  const dark = parseColor(opts.dark);
+  const light = parseColor(opts.light);
+
+  // --- Scanlines: filter byte 0, then one bit per pixel, MSB leftmost.
+  const bytesPerRow = (pixelWidth + 7) >> 3;
+  const raw = new Uint8Array((bytesPerRow + 1) * pixelHeight);
+
+  const rowBits = new Uint8Array(bytesPerRow);
+  for (let my = 0; my < source.height; my++) {
+    rowBits.fill(0);
+    for (let mx = 0; mx < source.width; mx++) {
+      if (!source.get(mx, my)) continue;
+      const from = mx * scale;
+      for (let px = from; px < from + scale; px++) {
+        rowBits[px >> 3] |= 0x80 >> (px & 7);
+      }
+    }
+    for (let py = 0; py < scale; py++) {
+      const offset = (my * scale + py) * (bytesPerRow + 1);
+      raw[offset] = 0; // filter type 0 (None)
+      raw.set(rowBits, offset + 1);
+    }
+  }
+
+  // --- Chunks.
+  const ihdr = new Uint8Array(13);
+  const ihdrView = new DataView(ihdr.buffer);
+  ihdrView.setUint32(0, pixelWidth);
+  ihdrView.setUint32(4, pixelHeight);
+  ihdr[8] = 1;   // bit depth
+  ihdr[9] = 3;   // colour type 3: palette
+  ihdr[10] = 0;  // compression: deflate
+  ihdr[11] = 0;  // filter method
+  ihdr[12] = 0;  // no interlace
+
+  // Palette index 0 is light (a clear module), index 1 is dark.
+  const plte = new Uint8Array([
+    light[0], light[1], light[2],
+    dark[0], dark[1], dark[2],
+  ]);
+
+  const parts = [SIGNATURE, chunk('IHDR', ihdr), chunk('PLTE', plte)];
+
+  // tRNS is only emitted when something is actually translucent, so the common
+  // opaque case produces a file every decoder handles identically.
+  if (light[3] < 255 || dark[3] < 255) {
+    parts.push(chunk('tRNS', new Uint8Array([light[3], dark[3]])));
+  }
+
+  parts.push(chunk('IDAT', await deflate(raw)));
+  parts.push(chunk('IEND', new Uint8Array(0)));
+
+  let total = 0;
+  for (const part of parts) total += part.length;
+  const file = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    file.set(part, offset);
+    offset += part.length;
+  }
+  return file;
+}
+
+/**
+ * Render to a data URI usable as an `<img>` src or a download href.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {Promise<string>}
+ */
+export async function toPNGDataURI(matrix, options = {}) {
+  const bytes = await toPNG(matrix, options);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  const base64 = typeof btoa === 'function'
+    ? btoa(binary)
+    /* eslint-disable-next-line no-undef */
+    : Buffer.from(bytes).toString('base64');
+  return 'data:image/png;base64,' + base64;
+}

package/src/render/svg.js

@@ -0,0 +1,120 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * SVG output.
+ *
+ * Dark modules are emitted as a single `<path>` with horizontal runs merged,
+ * not as one `<rect>` per module. A version 40 QR symbol has 31329 modules; the
+ * naive rendering is a megabyte of XML that browsers choke on, while the merged
+ * path is a few kilobytes and draws identically.
+ *
+ * @module render/svg
+ */
+
+import { normalizeOptions } from './options.js';
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeAttr(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Render to an SVG document.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {string}
+ */
+export function toSVG(matrix, options = {}) {
+  const opts = normalizeOptions(matrix, options);
+  const { scale, source, pixelWidth, pixelHeight, rowHeight } = opts;
+
+  let path = '';
+  for (let y = 0; y < source.height; y++) {
+    let x = 0;
+    while (x < source.width) {
+      if (!source.get(x, y)) { x++; continue; }
+      let run = 1;
+      while (x + run < source.width && source.get(x + run, y)) run++;
+      // Relative horizontal-vertical path commands: shorter than rects and
+      // free of the seams that appear between adjacent rects at some zooms.
+      path += `M${x * scale} ${y * rowHeight}h${run * scale}v${rowHeight}h${-run * scale}z`;
+      x += run;
+    }
+  }
+
+  const bg = opts.light === 'none'
+    ? ''
+    : `<rect width="${pixelWidth}" height="${pixelHeight}" fill="${escapeAttr(opts.light)}"/>`;
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${pixelWidth}" height="${pixelHeight}" ` +
+    `viewBox="0 0 ${pixelWidth} ${pixelHeight}" shape-rendering="crispEdges">` +
+    bg +
+    `<path d="${path}" fill="${escapeAttr(opts.dark)}"/>` +
+    '</svg>';
+}
+
+/**
+ * Base64 that works identically in Node and the browser.
+ *
+ * `btoa` is byte-oriented, so the UTF-8 encoding has to happen first — passing
+ * it a string with any character above U+00FF throws.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function toBase64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  if (typeof btoa === 'function') return btoa(binary);
+  // Node before btoa was global, and non-browser embedders.
+  /* eslint-disable-next-line no-undef */
+  return Buffer.from(bytes).toString('base64');
+}
+
+/**
+ * Render to a data URI usable directly as an `<img>` src.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {string}
+ */
+export function toSVGDataURI(matrix, options = {}) {
+  return 'data:image/svg+xml;base64,' + toBase64(toSVG(matrix, options));
+}

package/src/render/webgl.js

@@ -0,0 +1,206 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * WebGL2 drawing.
+ *
+ * The matrix is uploaded as a one-byte-per-module R8 texture and drawn with a
+ * fragment shader sampling it at NEAREST. That keeps module edges perfectly
+ * sharp at any zoom, which is the property that matters — a barcode resampled
+ * with interpolation stops being a barcode.
+ *
+ * Every entry point is failure-tolerant: no context, a lost context, a driver
+ * that rejects the shader — all return false so the caller falls back to the
+ * 2D path rather than showing the user nothing.
+ *
+ * @module render/webgl
+ */
+
+import { normalizeOptions, parseColor } from './options.js';
+
+const VERTEX_SHADER = `#version 300 es
+// A single oversized triangle covers the viewport with no vertex buffer:
+// three gl_VertexID lookups, no attribute state to set up or leak.
+out vec2 vUV;
+void main() {
+  vec2 pos = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);
+  vUV = pos;
+  gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
+}`;
+
+const FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+in vec2 vUV;
+out vec4 fragColor;
+uniform sampler2D uMatrix;
+uniform vec4 uDark;
+uniform vec4 uLight;
+uniform vec2 uSize;
+void main() {
+  // Flip Y: texture row 0 is the top of the symbol, but GL's origin is bottom.
+  vec2 uv = vec2(vUV.x, 1.0 - vUV.y);
+  // Sample at the centre of the module, never on a boundary, so rounding
+  // cannot pull a neighbouring module's value in at fractional scales.
+  vec2 texel = (floor(uv * uSize) + 0.5) / uSize;
+  float v = texture(uMatrix, texel).r;
+  fragColor = v > 0.5 ? uDark : uLight;
+}`;
+
+/**
+ * Is WebGL2 usable here?
+ *
+ * @returns {boolean}
+ */
+export function isWebGL2Available() {
+  try {
+    if (typeof document === 'undefined') return false;
+    if (typeof WebGL2RenderingContext === 'undefined') return false;
+    const probe = document.createElement('canvas');
+    const gl = probe.getContext('webgl2');
+    if (!gl) return false;
+    const lose = gl.getExtension('WEBGL_lose_context');
+    if (lose) lose.loseContext();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {WebGL2RenderingContext} gl
+ * @param {number} type
+ * @param {string} source
+ * @returns {WebGLShader | null}
+ */
+function compile(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (!shader) return null;
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    gl.deleteShader(shader);
+    return null;
+  }
+  return shader;
+}
+
+/**
+ * Draw a matrix into a canvas with WebGL2.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {HTMLCanvasElement | OffscreenCanvas} canvas
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {boolean} True if it drew; false means the caller should fall back.
+ */
+export function renderToCanvasWebGL(matrix, canvas, options = {}) {
+  let gl = null;
+  let program = null;
+  let vs = null;
+  let fs = null;
+  let texture = null;
+  let vao = null;
+
+  try {
+    const opts = normalizeOptions(matrix, options);
+    const { source, pixelWidth, pixelHeight } = opts;
+
+    gl = canvas.getContext('webgl2', { antialias: false, premultipliedAlpha: false });
+    if (!gl) return false;
+
+    canvas.width = pixelWidth;
+    canvas.height = pixelHeight;
+
+    vs = compile(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
+    fs = compile(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
+    if (!vs || !fs) return false;
+
+    program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) return false;
+    gl.useProgram(program);
+
+    // One byte per module. R8 is the narrowest single-channel format WebGL2
+    // guarantees as colour-renderable and filterable.
+    const pixels = new Uint8Array(source.width * source.height);
+    for (let y = 0; y < source.height; y++) {
+      for (let x = 0; x < source.width; x++) {
+        pixels[y * source.width + x] = source.get(x, y) ? 255 : 0;
+      }
+    }
+
+    texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texImage2D(
+      gl.TEXTURE_2D, 0, gl.R8,
+      source.width, source.height, 0,
+      gl.RED, gl.UNSIGNED_BYTE, pixels
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+    const dark = parseColor(opts.dark).map((c) => c / 255);
+    const light = parseColor(opts.light).map((c) => c / 255);
+
+    gl.uniform1i(gl.getUniformLocation(program, 'uMatrix'), 0);
+    gl.uniform4f(gl.getUniformLocation(program, 'uDark'), dark[0], dark[1], dark[2], dark[3]);
+    gl.uniform4f(gl.getUniformLocation(program, 'uLight'), light[0], light[1], light[2], light[3]);
+    gl.uniform2f(gl.getUniformLocation(program, 'uSize'), source.width, source.height);
+
+    // WebGL2 still requires a bound VAO even when drawing without attributes.
+    vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+
+    gl.viewport(0, 0, pixelWidth, pixelHeight);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+
+    return true;
+  } catch {
+    return false;
+  } finally {
+    // Release eagerly: a page generating many barcodes would otherwise hold
+    // every texture until GC caught up, and GL memory is not GC's priority.
+    if (gl) {
+      try {
+        if (vao) gl.deleteVertexArray(vao);
+        if (texture) gl.deleteTexture(texture);
+        if (program) gl.deleteProgram(program);
+        if (vs) gl.deleteShader(vs);
+        if (fs) gl.deleteShader(fs);
+      } catch {
+        /* context already gone */
+      }
+    }
+  }
+}