@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/aztec/encoder.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Aztec encoder: high-level bits, bit stuffing, Reed-Solomon and matrix layout.
  *
@@ -39,26 +38,23 @@
  *
  * @module aztec/encoder
  */
-
 import { BitWriter } from '../core/bit-buffer.js';
 import { BitMatrix } from '../core/bit-matrix.js';
 import { EncodeError } from '../core/errors.js';
 import { rsEncode } from '../core/reed-solomon.js';
 import { encodeHighLevel } from './high-level.js';
 import { AZTEC_COMPACT_LAYERS, AZTEC_FULL_LAYERS, aztecLayer, eccCodewordsFor, fieldForLayers, fieldForWordSize, wordSizeForLayers } from './tables.js';
-
 /** @param {BitWriter} bits @param {number} at @returns {boolean} */
 function bitAt(bits, at) {
-  return at >= 0 && at < bits.length && ((bits.bytes[at >>> 3] >>> (7 - (at & 7))) & 1) !== 0;
+    return at >= 0 && at < bits.length && ((bits.bytes[at >>> 3] >>> (7 - (at & 7))) & 1) !== 0;
 }
-
 /** @param {BitWriter} bits @param {number} from @param {number} count @returns {number} */
 function readBits(bits, from, count) {
-  let value = 0;
-  for (let i = 0; i < count; i++) value = (value << 1) | (bitAt(bits, from + i) ? 1 : 0);
-  return value;
+    let value = 0;
+    for (let i = 0; i < count; i++)
+        value = (value << 1) | (bitAt(bits, from + i) ? 1 : 0);
+    return value;
 }
-
 /**
  * Prevent all-zero and all-one codewords except their final bit.  The final
  * bit is intentionally re-consumed after a stuffed word; it is the mechanism
@@ -67,23 +63,24 @@ function readBits(bits, from, count) {
  * @param {BitWriter} bits @param {number} wordSize @returns {BitWriter}
  */
 export function stuffBits(bits, wordSize) {
-  const out = new BitWriter();
-  const reserved = (1 << wordSize) - 2;
-  for (let at = 0; at < bits.length; at += wordSize) {
-    const word = readBits(bits, at, wordSize);
-    if ((word & reserved) === reserved) {
-      out.put(word & reserved, wordSize);
-      at--;
-    } else if ((word & reserved) === 0) {
-      out.put(word | 1, wordSize);
-      at--;
-    } else {
-      out.put(word, wordSize);
+    const out = new BitWriter();
+    const reserved = (1 << wordSize) - 2;
+    for (let at = 0; at < bits.length; at += wordSize) {
+        const word = readBits(bits, at, wordSize);
+        if ((word & reserved) === reserved) {
+            out.put(word & reserved, wordSize);
+            at--;
+        }
+        else if ((word & reserved) === 0) {
+            out.put(word | 1, wordSize);
+            at--;
+        }
+        else {
+            out.put(word, wordSize);
+        }
     }
-  }
-  return out;
+    return out;
 }
-
 /**
  * Add systematic Aztec Reed-Solomon parity and the leading alignment bits.
  * @param {BitWriter} data @param {number} totalBits @param {number} wordSize
@@ -91,137 +88,155 @@ export function stuffBits(bits, wordSize) {
  * @returns {{bits: BitWriter, dataWords: number, eccWords: number}}
  */
 export function addCheckWords(data, totalBits, wordSize, field) {
-  const totalWords = Math.floor(totalBits / wordSize);
-  const dataWords = Math.ceil(data.length / wordSize);
-  if (dataWords > totalWords) throw new EncodeError('Aztec: data codewords exceed layer capacity');
-  const eccWords = totalWords - dataWords;
-  const words = new Array(dataWords);
-  for (let i = 0; i < dataWords; i++) words[i] = readBits(data, i * wordSize, wordSize);
-  const ecc = rsEncode(words, eccWords, field, 1);
-  const out = new BitWriter();
-  out.put(0, totalBits % wordSize);
-  for (const word of words) out.put(word, wordSize);
-  for (const word of ecc) out.put(word, wordSize);
-  return { bits: out, dataWords, eccWords };
+    const totalWords = Math.floor(totalBits / wordSize);
+    const dataWords = Math.ceil(data.length / wordSize);
+    if (dataWords > totalWords)
+        throw new EncodeError('Aztec: data codewords exceed layer capacity');
+    const eccWords = totalWords - dataWords;
+    const words = new Array(dataWords);
+    for (let i = 0; i < dataWords; i++)
+        words[i] = readBits(data, i * wordSize, wordSize);
+    const ecc = rsEncode(words, eccWords, field, 1);
+    const out = new BitWriter();
+    out.put(0, totalBits % wordSize);
+    for (const word of words)
+        out.put(word, wordSize);
+    for (const word of ecc)
+        out.put(word, wordSize);
+    return { bits: out, dataWords, eccWords };
 }
-
 /** @param {number} layers @param {number} dataWords @param {boolean} compact @returns {BitWriter} */
 export function modeMessage(layers, dataWords, compact) {
-  const raw = new BitWriter();
-  if (compact) {
-    raw.put(layers - 1, 2);
-    raw.put(dataWords - 1, 6);
-    return addCheckWords(raw, 28, 4, fieldForWordSize(4)).bits;
-  }
-  raw.put(layers - 1, 5);
-  raw.put(dataWords - 1, 11);
-  return addCheckWords(raw, 40, 4, fieldForWordSize(4)).bits;
+    const raw = new BitWriter();
+    if (compact) {
+        raw.put(layers - 1, 2);
+        raw.put(dataWords - 1, 6);
+        return addCheckWords(raw, 28, 4, fieldForWordSize(4)).bits;
+    }
+    raw.put(layers - 1, 5);
+    raw.put(dataWords - 1, 11);
+    return addCheckWords(raw, 40, 4, fieldForWordSize(4)).bits;
 }
-
 /** @param {BitMatrix} matrix @param {number} center @param {number} size */
 function drawBullsEye(matrix, center, size) {
-  for (let ring = 0; ring < size; ring += 2) {
-    for (let p = center - ring; p <= center + ring; p++) {
-      matrix.set(p, center - ring); matrix.set(p, center + ring);
-      matrix.set(center - ring, p); matrix.set(center + ring, p);
+    for (let ring = 0; ring < size; ring += 2) {
+        for (let p = center - ring; p <= center + ring; p++) {
+            matrix.set(p, center - ring);
+            matrix.set(p, center + ring);
+            matrix.set(center - ring, p);
+            matrix.set(center + ring, p);
+        }
     }
-  }
-  matrix.set(center - size, center - size);
-  matrix.set(center - size + 1, center - size);
-  matrix.set(center - size, center - size + 1);
-  matrix.set(center + size, center - size);
-  matrix.set(center + size, center - size + 1);
-  matrix.set(center + size, center + size - 1);
+    matrix.set(center - size, center - size);
+    matrix.set(center - size + 1, center - size);
+    matrix.set(center - size, center - size + 1);
+    matrix.set(center + size, center - size);
+    matrix.set(center + size, center - size + 1);
+    matrix.set(center + size, center + size - 1);
 }
-
 /** @param {BitMatrix} matrix @param {BitWriter} message @param {boolean} compact @param {number} center */
 function drawModeMessage(matrix, message, compact, center) {
-  if (compact) {
-    for (let i = 0; i < 7; i++) {
-      const offset = center - 3 + i;
-      if (bitAt(message, i)) matrix.set(offset, center - 5);
-      if (bitAt(message, i + 7)) matrix.set(center + 5, offset);
-      if (bitAt(message, 20 - i)) matrix.set(offset, center + 5);
-      if (bitAt(message, 27 - i)) matrix.set(center - 5, offset);
+    if (compact) {
+        for (let i = 0; i < 7; i++) {
+            const offset = center - 3 + i;
+            if (bitAt(message, i))
+                matrix.set(offset, center - 5);
+            if (bitAt(message, i + 7))
+                matrix.set(center + 5, offset);
+            if (bitAt(message, 20 - i))
+                matrix.set(offset, center + 5);
+            if (bitAt(message, 27 - i))
+                matrix.set(center - 5, offset);
+        }
     }
-  } else {
-    for (let i = 0; i < 10; i++) {
-      const offset = center - 5 + i + Math.floor(i / 5);
-      if (bitAt(message, i)) matrix.set(offset, center - 7);
-      if (bitAt(message, i + 10)) matrix.set(center + 7, offset);
-      if (bitAt(message, 29 - i)) matrix.set(offset, center + 7);
-      if (bitAt(message, 39 - i)) matrix.set(center - 7, offset);
+    else {
+        for (let i = 0; i < 10; i++) {
+            const offset = center - 5 + i + Math.floor(i / 5);
+            if (bitAt(message, i))
+                matrix.set(offset, center - 7);
+            if (bitAt(message, i + 10))
+                matrix.set(center + 7, offset);
+            if (bitAt(message, 29 - i))
+                matrix.set(offset, center + 7);
+            if (bitAt(message, 39 - i))
+                matrix.set(center - 7, offset);
+        }
     }
-  }
 }
-
 /**
  * Lay low-level bits in the four-sided, inward Aztec spiral.
  * @param {BitWriter} bits @param {{layers:number,compact:boolean,baseMatrixSize:number,symbolSize:number}} symbol
  * @returns {BitMatrix}
  */
 export function buildAztecMatrix(bits, symbol) {
-  const { layers, compact, baseMatrixSize, symbolSize } = symbol;
-  const matrix = new BitMatrix(symbolSize);
-  const alignment = new Int32Array(baseMatrixSize);
-  const center = Math.floor(symbolSize / 2);
-
-  if (compact) {
-    for (let i = 0; i < baseMatrixSize; i++) alignment[i] = i;
-  } else {
-    const originalCenter = Math.floor(baseMatrixSize / 2);
-    for (let i = 0; i < originalCenter; i++) {
-      const offset = i + Math.floor(i / 15);
-      alignment[originalCenter - i - 1] = center - offset - 1;
-      alignment[originalCenter + i] = center + offset + 1;
+    const { layers, compact, baseMatrixSize, symbolSize } = symbol;
+    const matrix = new BitMatrix(symbolSize);
+    const alignment = new Int32Array(baseMatrixSize);
+    const center = Math.floor(symbolSize / 2);
+    if (compact) {
+        for (let i = 0; i < baseMatrixSize; i++)
+            alignment[i] = i;
+    }
+    else {
+        const originalCenter = Math.floor(baseMatrixSize / 2);
+        for (let i = 0; i < originalCenter; i++) {
+            const offset = i + Math.floor(i / 15);
+            alignment[originalCenter - i - 1] = center - offset - 1;
+            alignment[originalCenter + i] = center + offset + 1;
+        }
     }
-  }
-
-  let bit = 0;
-  for (let layer = 0; layer < layers; layer++) {
-    const rowSize = (layers - layer) * 4 + (compact ? 9 : 12);
-    const low = layer * 2;
-    const high = baseMatrixSize - 1 - low;
-    for (let j = 0; j < rowSize; j++) {
-      const offset = j * 2;
-      for (let k = 0; k < 2; k++) {
-        if (bitAt(bits, bit + offset + k)) matrix.set(alignment[low + k], alignment[low + j]);
-        if (bitAt(bits, bit + rowSize * 2 + offset + k)) matrix.set(alignment[low + j], alignment[high - k]);
-        if (bitAt(bits, bit + rowSize * 4 + offset + k)) matrix.set(alignment[high - k], alignment[high - j]);
-        if (bitAt(bits, bit + rowSize * 6 + offset + k)) matrix.set(alignment[high - j], alignment[low + k]);
-      }
+    let bit = 0;
+    for (let layer = 0; layer < layers; layer++) {
+        const rowSize = (layers - layer) * 4 + (compact ? 9 : 12);
+        const low = layer * 2;
+        const high = baseMatrixSize - 1 - low;
+        for (let j = 0; j < rowSize; j++) {
+            const offset = j * 2;
+            for (let k = 0; k < 2; k++) {
+                if (bitAt(bits, bit + offset + k))
+                    matrix.set(alignment[low + k], alignment[low + j]);
+                if (bitAt(bits, bit + rowSize * 2 + offset + k))
+                    matrix.set(alignment[low + j], alignment[high - k]);
+                if (bitAt(bits, bit + rowSize * 4 + offset + k))
+                    matrix.set(alignment[high - k], alignment[high - j]);
+                if (bitAt(bits, bit + rowSize * 6 + offset + k))
+                    matrix.set(alignment[high - j], alignment[low + k]);
+            }
+        }
+        bit += rowSize * 8;
     }
-    bit += rowSize * 8;
-  }
-  if (bit !== bits.length) throw new EncodeError(`Aztec: layout consumed ${bit} of ${bits.length} bits`);
-
-  const mode = modeMessage(layers, symbol.dataWords, compact);
-  drawModeMessage(matrix, mode, compact, center);
-  drawBullsEye(matrix, center, compact ? 5 : 7);
-
-  if (!compact) {
-    for (let i = 0, offset = 0; i < Math.floor(baseMatrixSize / 2) - 1; i += 15, offset += 16) {
-      for (let p = center & 1; p < symbolSize; p += 2) {
-        matrix.set(center - offset, p); matrix.set(center + offset, p);
-        matrix.set(p, center - offset); matrix.set(p, center + offset);
-      }
+    if (bit !== bits.length)
+        throw new EncodeError(`Aztec: layout consumed ${bit} of ${bits.length} bits`);
+    const mode = modeMessage(layers, symbol.dataWords, compact);
+    drawModeMessage(matrix, mode, compact, center);
+    drawBullsEye(matrix, center, compact ? 5 : 7);
+    if (!compact) {
+        for (let i = 0, offset = 0; i < Math.floor(baseMatrixSize / 2) - 1; i += 15, offset += 16) {
+            for (let p = center & 1; p < symbolSize; p += 2) {
+                matrix.set(center - offset, p);
+                matrix.set(center + offset, p);
+                matrix.set(p, center - offset);
+                matrix.set(p, center + offset);
+            }
+        }
     }
-  }
-  return matrix;
+    return matrix;
 }
-
 /** @param {number | undefined} layers @param {boolean | undefined} compact */
 function candidates(layers, compact) {
-  if (layers !== undefined) {
-    if (!Number.isInteger(layers) || layers < 1 || layers > 32) throw new EncodeError('Aztec: layers must be an integer 1..32');
-    if (compact === true && layers > 4) throw new EncodeError('Aztec: compact symbols support layers 1..4');
-    return [aztecLayer(layers, compact === true)];
-  }
-  if (compact === true) return AZTEC_COMPACT_LAYERS;
-  if (compact === false) return AZTEC_FULL_LAYERS;
-  return [...AZTEC_COMPACT_LAYERS, ...AZTEC_FULL_LAYERS];
+    if (layers !== undefined) {
+        if (!Number.isInteger(layers) || layers < 1 || layers > 32)
+            throw new EncodeError('Aztec: layers must be an integer 1..32');
+        if (compact === true && layers > 4)
+            throw new EncodeError('Aztec: compact symbols support layers 1..4');
+        return [aztecLayer(layers, compact === true)];
+    }
+    if (compact === true)
+        return AZTEC_COMPACT_LAYERS;
+    if (compact === false)
+        return AZTEC_FULL_LAYERS;
+    return [...AZTEC_COMPACT_LAYERS, ...AZTEC_FULL_LAYERS];
 }
-
 /**
  * Encode a UTF-8 string or bytes into an Aztec Code matrix.
  *
@@ -230,28 +245,32 @@ function candidates(layers, compact) {
  * @returns {BitMatrix & {format?:string,layers?:number,compact?:boolean,eccPercent?:number,dataCodewords?:number}}
  */
 export function encodeAztec(value, options = {}) {
-  const eccPercent = options.eccPercent ?? 23;
-  if (!Number.isFinite(eccPercent) || eccPercent < 5 || eccPercent > 95) {
-    throw new EncodeError('Aztec: eccPercent must be between 5 and 95');
-  }
-  const high = encodeHighLevel(value, { charset: options.charset ?? 'utf-8' });
-  for (const candidate of candidates(options.layers, options.compact)) {
-    if (!candidate) continue;
-    const wordSize = wordSizeForLayers(candidate.layers);
-    const stuffed = stuffBits(high, wordSize);
-    const dataWords = Math.ceil(stuffed.length / wordSize);
-    const eccWords = eccCodewordsFor(dataWords, eccPercent);
-    if (dataWords > candidate.maxDataCodewords || dataWords + eccWords > candidate.totalCodewords) continue;
-    const checked = addCheckWords(stuffed, candidate.totalBits, wordSize, fieldForLayers(candidate.layers));
-    // `addCheckWords` uses every remaining word as parity.  This is stronger
-    // than the requested percentage, never weaker, and canonical for a chosen
-    // layer/data-word combination.
-    const symbol = { ...candidate, dataWords: checked.dataWords };
-    const matrix = buildAztecMatrix(checked.bits, symbol);
-    matrix.format = 'aztec'; matrix.layers = candidate.layers; matrix.compact = candidate.compact;
-    matrix.eccPercent = Math.round(checked.eccWords * wordSize * 100 / Math.max(1, stuffed.length));
-    matrix.dataCodewords = checked.dataWords;
-    return matrix;
-  }
-  throw new EncodeError('Aztec: payload does not fit the requested layers and error correction');
+    const eccPercent = options.eccPercent ?? 23;
+    if (!Number.isFinite(eccPercent) || eccPercent < 5 || eccPercent > 95) {
+        throw new EncodeError('Aztec: eccPercent must be between 5 and 95');
+    }
+    const high = encodeHighLevel(value, { charset: options.charset ?? 'utf-8' });
+    for (const candidate of candidates(options.layers, options.compact)) {
+        if (!candidate)
+            continue;
+        const wordSize = wordSizeForLayers(candidate.layers);
+        const stuffed = stuffBits(high, wordSize);
+        const dataWords = Math.ceil(stuffed.length / wordSize);
+        const eccWords = eccCodewordsFor(dataWords, eccPercent);
+        if (dataWords > candidate.maxDataCodewords || dataWords + eccWords > candidate.totalCodewords)
+            continue;
+        const checked = addCheckWords(stuffed, candidate.totalBits, wordSize, fieldForLayers(candidate.layers));
+        // `addCheckWords` uses every remaining word as parity.  This is stronger
+        // than the requested percentage, never weaker, and canonical for a chosen
+        // layer/data-word combination.
+        const symbol = { ...candidate, dataWords: checked.dataWords };
+        const matrix = buildAztecMatrix(checked.bits, symbol);
+        matrix.format = 'aztec';
+        matrix.layers = candidate.layers;
+        matrix.compact = candidate.compact;
+        matrix.eccPercent = Math.round(checked.eccWords * wordSize * 100 / Math.max(1, stuffed.length));
+        matrix.dataCodewords = checked.dataWords;
+        return matrix;
+    }
+    throw new EncodeError('Aztec: payload does not fit the requested layers and error correction');
 }