@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/render/png.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * PNG output, with no dependencies and no compression library of our own.
  *
@@ -48,61 +47,54 @@
  *
  * @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;
+    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;
     }
-    table[n] = c >>> 0;
-  }
-  return table;
+    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;
+    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;
+    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;
     }
-    a %= 65521;
-    b %= 65521;
-  }
-  return ((b << 16) | a) >>> 0;
+    return ((b << 16) | a) >>> 0;
 }
-
 /* ------------------------------------------------------------------ *
  * Deflate
  * ------------------------------------------------------------------ */
-
 /**
  * Wrap data in stored (type 00) deflate blocks with a zlib header.
  *
@@ -115,40 +107,33 @@ function adler32(bytes) {
  * @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);
+    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.
  *
@@ -156,52 +141,49 @@ export function deflateStored(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 */
+    // 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 */
+    // 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);
+    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;
+    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.
  *
@@ -210,72 +192,64 @@ function chunk(type, payload) {
  * @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);
-      }
+    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]])));
     }
-    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);
+    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;
     }
-  }
-
-  // --- 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;
+    return file;
 }
-
 /**
  * Render to a data URI usable as an `<img>` src or a download href.
  *
@@ -284,12 +258,13 @@ export async function toPNG(matrix, 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;
+    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/js/render/svg.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * SVG output.
  *
@@ -38,21 +37,18 @@
  *
  * @module render/svg
  */
-
 import { normalizeOptions } from './options.js';
-
 /**
  * @param {string} value
  * @returns {string}
  */
 function escapeAttr(value) {
-  return String(value)
-    .replace(/&/g, '&')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
+    return String(value)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
 }
-
 /**
  * Render to an SVG document.
  *
@@ -61,34 +57,34 @@ function escapeAttr(value) {
  * @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 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>';
+    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.
  *
@@ -99,15 +95,16 @@ export function toSVG(matrix, options = {}) {
  * @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');
+    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.
  *
@@ -116,5 +113,5 @@ function toBase64(text) {
  * @returns {string}
  */
 export function toSVGDataURI(matrix, options = {}) {
-  return 'data:image/svg+xml;base64,' + toBase64(toSVG(matrix, options));
+    return 'data:image/svg+xml;base64,' + toBase64(toSVG(matrix, options));
 }