@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/aztecrune/decoder.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Aztec Rune decoder.
  *
@@ -39,74 +38,66 @@
  *
  * @module aztecrune/decoder
  */
-
 import { FormatError } from '../core/errors.js';
 import { rsDecode } from '../core/reed-solomon.js';
-import {
-  AZTEC_RUNE_DATA_CODEWORDS,
-  AZTEC_RUNE_DATA_POSITIONS,
-  AZTEC_RUNE_ECC_CODEWORDS,
-  AZTEC_RUNE_MASK,
-  AZTEC_RUNE_SIZE,
-  aztecRuneField,
-  aztecRuneStructuralValue,
-} from './tables.js';
-
+import { AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, aztecRuneStructuralValue, } from './tables.js';
 /** @param {import('../core/bit-matrix.js').BitMatrix} source @param {number} turns */
 function rotateClockwise(source, turns) {
-  let current = source.clone();
-  for (let turn = 0; turn < turns; turn++) {
-    const out = new source.constructor(current.height, current.width);
-    for (let y = 0; y < current.height; y++) for (let x = 0; x < current.width; x++) {
-      if (current.get(x, y)) out.set(current.height - 1 - y, x);
+    let current = source.clone();
+    for (let turn = 0; turn < turns; turn++) {
+        const out = new source.constructor(current.height, current.width);
+        for (let y = 0; y < current.height; y++)
+            for (let x = 0; x < current.width; x++) {
+                if (current.get(x, y))
+                    out.set(current.height - 1 - y, x);
+            }
+        current = out;
     }
-    current = out;
-  }
-  return current;
+    return current;
 }
-
 /** @param {import('../core/bit-matrix.js').BitMatrix} matrix */
 function invert(matrix) {
-  const out = matrix.clone();
-  for (let y = 0; y < out.height; y++) for (let x = 0; x < out.width; x++) out.flip(x, y);
-  return out;
+    const out = matrix.clone();
+    for (let y = 0; y < out.height; y++)
+        for (let x = 0; x < out.width; x++)
+            out.flip(x, y);
+    return out;
 }
-
 /** @param {import('../core/bit-matrix.js').BitMatrix} matrix @param {boolean} inverted */
 function structureMatches(matrix, inverted) {
-  for (let y = 0; y < AZTEC_RUNE_SIZE; y++) for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
-    const expected = aztecRuneStructuralValue(x, y);
-    if (expected === null) continue;
-    if (matrix.get(x, y) !== (inverted ? !expected : expected)) return false;
-  }
-  return true;
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            const expected = aztecRuneStructuralValue(x, y);
+            if (expected === null)
+                continue;
+            if (matrix.get(x, y) !== (inverted ? !expected : expected))
+                return false;
+        }
+    return true;
 }
-
 /** @param {import('../core/bit-matrix.js').BitMatrix} matrix @param {boolean} inverted */
 function readCodewords(matrix, inverted) {
-  const words = new Array(2 + AZTEC_RUNE_ECC_CODEWORDS).fill(0);
-  for (let at = 0; at < AZTEC_RUNE_DATA_POSITIONS.length; at++) {
-    const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
-    const bit = matrix.get(x, y) !== inverted;
-    words[at >>> 2] = (words[at >>> 2] << 1) | (bit ? 1 : 0);
-  }
-  return words.map((word) => word ^ AZTEC_RUNE_MASK);
+    const words = new Array(2 + AZTEC_RUNE_ECC_CODEWORDS).fill(0);
+    for (let at = 0; at < AZTEC_RUNE_DATA_POSITIONS.length; at++) {
+        const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
+        const bit = matrix.get(x, y) !== inverted;
+        words[at >>> 2] = (words[at >>> 2] << 1) | (bit ? 1 : 0);
+    }
+    return words.map((word) => word ^ AZTEC_RUNE_MASK);
 }
-
 /** @param {number} value @param {boolean} inverted @param {number} rotation @param {number} corrections */
 function result(value, inverted, rotation, corrections) {
-  return {
-    format: 'aztecrune',
-    value,
-    text: String(value).padStart(3, '0'),
-    bytes: Uint8Array.of(value),
-    dimension: AZTEC_RUNE_SIZE,
-    inverted,
-    rotation,
-    corrections,
-  };
+    return {
+        format: 'aztecrune',
+        value,
+        text: String(value).padStart(3, '0'),
+        bytes: Uint8Array.of(value),
+        dimension: AZTEC_RUNE_SIZE,
+        inverted,
+        rotation,
+        corrections,
+    };
 }
-
 /**
  * Decode a square Aztec Rune matrix.
  *
@@ -116,40 +107,40 @@ function result(value, inverted, rotation, corrections) {
  * @throws {FormatError} For non-Rune geometry, structure or uncorrectable data.
  */
 export function decodeAztecRune(matrix, options = {}) {
-  if (!matrix || matrix.width !== AZTEC_RUNE_SIZE || matrix.height !== AZTEC_RUNE_SIZE) {
-    throw new FormatError(`Aztec Rune: expected an ${AZTEC_RUNE_SIZE}x${AZTEC_RUNE_SIZE} module matrix`);
-  }
-  const invertedModes = options.inverted === true ? [true] : options.inverted === false ? [false] : [false, true];
-  const rotations = Number.isInteger(options.rotation)
-    ? [((options.rotation % 360) + 360) % 360]
-    : [0, 90, 180, 270];
-
-  let checksumError = null;
-  for (const requestedRotation of rotations) {
-    if (requestedRotation % 90 !== 0) continue;
-    // To canonicalize an input rotated clockwise by k degrees, rotate it
-    // counter-clockwise by k. `turns` is the clockwise operation we apply.
-    const turns = (4 - requestedRotation / 90) % 4;
-    const canonicalRotation = requestedRotation;
-    const rotated = turns === 0 ? matrix.clone() : rotateClockwise(matrix, turns);
-    for (const inverted of invertedModes) {
-      const canonical = inverted ? invert(rotated) : rotated;
-      if (!structureMatches(canonical, false)) continue;
-      const words = readCodewords(canonical, false);
-      try {
-        const corrections = rsDecode(words, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
-        const value = (words[0] << 4) | words[1];
-        return result(value, inverted, canonicalRotation, corrections);
-      } catch (error) {
-        checksumError = error;
-      }
+    if (!matrix || matrix.width !== AZTEC_RUNE_SIZE || matrix.height !== AZTEC_RUNE_SIZE) {
+        throw new FormatError(`Aztec Rune: expected an ${AZTEC_RUNE_SIZE}x${AZTEC_RUNE_SIZE} module matrix`);
+    }
+    const invertedModes = options.inverted === true ? [true] : options.inverted === false ? [false] : [false, true];
+    const rotations = Number.isInteger(options.rotation)
+        ? [((options.rotation % 360) + 360) % 360]
+        : [0, 90, 180, 270];
+    let checksumError = null;
+    for (const requestedRotation of rotations) {
+        if (requestedRotation % 90 !== 0)
+            continue;
+        // To canonicalize an input rotated clockwise by k degrees, rotate it
+        // counter-clockwise by k. `turns` is the clockwise operation we apply.
+        const turns = (4 - requestedRotation / 90) % 4;
+        const canonicalRotation = requestedRotation;
+        const rotated = turns === 0 ? matrix.clone() : rotateClockwise(matrix, turns);
+        for (const inverted of invertedModes) {
+            const canonical = inverted ? invert(rotated) : rotated;
+            if (!structureMatches(canonical, false))
+                continue;
+            const words = readCodewords(canonical, false);
+            try {
+                const corrections = rsDecode(words, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
+                const value = (words[0] << 4) | words[1];
+                return result(value, inverted, canonicalRotation, corrections);
+            }
+            catch (error) {
+                checksumError = error;
+            }
+        }
+    }
+    if (checksumError) {
+        throw new FormatError(`Aztec Rune: Reed-Solomon check failed: ${checksumError.message}`);
     }
-  }
-
-  if (checksumError) {
-    throw new FormatError(`Aztec Rune: Reed-Solomon check failed: ${checksumError.message}`);
-  }
-  throw new FormatError('Aztec Rune: structural pattern or orientation is invalid');
+    throw new FormatError('Aztec Rune: structural pattern or orientation is invalid');
 }
-
 export { readCodewords, structureMatches };

package/src/js/aztecrune/detector.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Detector for Aztec Rune symbols.
  *
@@ -39,14 +38,11 @@
  *
  * @module aztecrune/detector
  */
-
 import { NotFoundError } from '../core/errors.js';
 import { BitMatrix } from '../core/bit-matrix.js';
 import { decodeAztecRune } from './decoder.js';
 import { AZTEC_RUNE_SIZE } from './tables.js';
-
 /** @typedef {{x:number,y:number}} Point */
-
 /**
  * Find connected components of a polarity. Components touching the image
  * border are ignored when they exceed the plausible module area; this avoids
@@ -54,73 +50,78 @@ import { AZTEC_RUNE_SIZE } from './tables.js';
  * Rune's isolated light centre module.
  */
 function components(image, value) {
-  const width = image.width;
-  const height = image.height;
-  const seen = new Uint8Array(width * height);
-  const limit = Math.max(64, Math.floor(width * height * 0.04));
-  const found = [];
-
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const start = y * width + x;
-    if (seen[start] || image.get(x, y) !== value) continue;
-    const queue = [[x, y]];
-    seen[start] = 1;
-    let head = 0;
-    let minX = x; let maxX = x; let minY = y; let maxY = y;
-    let count = 0;
-    let touchesBorder = false;
-
-    while (head < queue.length) {
-      const [px, py] = queue[head++];
-      count++;
-      minX = Math.min(minX, px); maxX = Math.max(maxX, px);
-      minY = Math.min(minY, py); maxY = Math.max(maxY, py);
-      if (px === 0 || py === 0 || px === width - 1 || py === height - 1) touchesBorder = true;
-      for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
-        if (nx < 0 || ny < 0 || nx >= width || ny >= height) continue;
-        const at = ny * width + nx;
-        if (!seen[at] && image.get(nx, ny) === value) {
-          seen[at] = 1;
-          queue.push([nx, ny]);
+    const width = image.width;
+    const height = image.height;
+    const seen = new Uint8Array(width * height);
+    const limit = Math.max(64, Math.floor(width * height * 0.04));
+    const found = [];
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const start = y * width + x;
+            if (seen[start] || image.get(x, y) !== value)
+                continue;
+            const queue = [[x, y]];
+            seen[start] = 1;
+            let head = 0;
+            let minX = x;
+            let maxX = x;
+            let minY = y;
+            let maxY = y;
+            let count = 0;
+            let touchesBorder = false;
+            while (head < queue.length) {
+                const [px, py] = queue[head++];
+                count++;
+                minX = Math.min(minX, px);
+                maxX = Math.max(maxX, px);
+                minY = Math.min(minY, py);
+                maxY = Math.max(maxY, py);
+                if (px === 0 || py === 0 || px === width - 1 || py === height - 1)
+                    touchesBorder = true;
+                for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+                    if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                        continue;
+                    const at = ny * width + nx;
+                    if (!seen[at] && image.get(nx, ny) === value) {
+                        seen[at] = 1;
+                        queue.push([nx, ny]);
+                    }
+                }
+            }
+            const boxWidth = maxX - minX + 1;
+            const boxHeight = maxY - minY + 1;
+            if (count <= limit && !touchesBorder &&
+                Math.abs(boxWidth - boxHeight) <= Math.max(1, Math.ceil(Math.max(boxWidth, boxHeight) * 0.35)) &&
+                count >= boxWidth * boxHeight * 0.45) {
+                found.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width: boxWidth, height: boxHeight, count });
+            }
         }
-      }
-    }
-
-    const boxWidth = maxX - minX + 1;
-    const boxHeight = maxY - minY + 1;
-    if (count <= limit && !touchesBorder &&
-      Math.abs(boxWidth - boxHeight) <= Math.max(1, Math.ceil(Math.max(boxWidth, boxHeight) * 0.35)) &&
-      count >= boxWidth * boxHeight * 0.45) {
-      found.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width: boxWidth, height: boxHeight, count });
-    }
-  }
-  return found.sort((a, b) => b.count - a.count);
+    return found.sort((a, b) => b.count - a.count);
 }
 /** @param {import('../core/bit-matrix.js').BitMatrix} image @param {Point} center @param {number} pitch */
 function sample(image, center, pitch) {
-  const matrix = new BitMatrix(AZTEC_RUNE_SIZE);
-  for (let y = 0; y < AZTEC_RUNE_SIZE; y++) for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
-    const px = Math.round(center.x + (x - 5) * pitch);
-    const py = Math.round(center.y + (y - 5) * pitch);
-    if (px >= 0 && py >= 0 && px < image.width && py < image.height && image.get(px, py)) matrix.set(x, y);
-  }
-  return matrix;
+    const matrix = new BitMatrix(AZTEC_RUNE_SIZE);
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            const px = Math.round(center.x + (x - 5) * pitch);
+            const py = Math.round(center.y + (y - 5) * pitch);
+            if (px >= 0 && py >= 0 && px < image.width && py < image.height && image.get(px, py))
+                matrix.set(x, y);
+        }
+    return matrix;
 }
-
 function corners(center, pitch) {
-  const half = AZTEC_RUNE_SIZE * pitch / 2;
-  return [
-    { x: center.x - half, y: center.y - half },
-    { x: center.x + half, y: center.y - half },
-    { x: center.x + half, y: center.y + half },
-    { x: center.x - half, y: center.y + half },
-  ];
+    const half = AZTEC_RUNE_SIZE * pitch / 2;
+    return [
+        { x: center.x - half, y: center.y - half },
+        { x: center.x + half, y: center.y - half },
+        { x: center.x + half, y: center.y + half },
+        { x: center.x - half, y: center.y + half },
+    ];
 }
-
 function sameCandidate(left, right) {
-  return Math.hypot(left.center.x - right.center.x, left.center.y - right.center.y) <= Math.max(left.moduleSize, right.moduleSize) * 2;
+    return Math.hypot(left.center.x - right.center.x, left.center.y - right.center.y) <= Math.max(left.moduleSize, right.moduleSize) * 2;
 }
-
 /**
  * Detect the most prominent Aztec Rune in a binarized image.
  *
@@ -128,39 +129,52 @@ function sameCandidate(left, right) {
  * @returns {{corners:Point[],dimension:11,moduleSize:number,matrix:BitMatrix,result:object}|null}
  */
 export function detectAztecRune(binaryImage) {
-  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
-    throw new NotFoundError('detectAztecRune: no image supplied');
-  }
-  const candidates = [];
-  for (const value of [true, false]) {
-    for (const component of components(binaryImage, value)) {
-      const pitch = (component.width + component.height) / 2;
-      if (pitch < 0.8) continue;
-      const matrix = sample(binaryImage, component, pitch);
-      let decoded;
-      try { decoded = decodeAztecRune(matrix); } catch { continue; }
-      const candidate = {
-        center: component,
-        corners: corners(component, pitch),
-        dimension: AZTEC_RUNE_SIZE,
-        moduleSize: pitch,
-        matrix,
-        result: decoded,
-      };
-      if (!candidates.some((entry) => sameCandidate(entry, candidate))) candidates.push(candidate);
+    if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+        throw new NotFoundError('detectAztecRune: no image supplied');
     }
-  }
-  candidates.sort((a, b) => b.moduleSize - a.moduleSize);
-  const best = candidates[0];
-  if (!best) return null;
-  delete best.center;
-  return best;
+    const candidates = [];
+    for (const value of [true, false]) {
+        for (const component of components(binaryImage, value)) {
+            const pitch = (component.width + component.height) / 2;
+            if (pitch < 0.8)
+                continue;
+            const matrix = sample(binaryImage, component, pitch);
+            let decoded;
+            try {
+                decoded = decodeAztecRune(matrix);
+            }
+            catch {
+                continue;
+            }
+            const candidate = {
+                center: component,
+                corners: corners(component, pitch),
+                dimension: AZTEC_RUNE_SIZE,
+                moduleSize: pitch,
+                matrix,
+                result: decoded,
+            };
+            if (!candidates.some((entry) => sameCandidate(entry, candidate)))
+                candidates.push(candidate);
+        }
+    }
+    candidates.sort((a, b) => b.moduleSize - a.moduleSize);
+    const best = candidates[0];
+    if (!best)
+        return null;
+    delete best.center;
+    return best;
 }
-
 /** Detect and decode one Aztec Rune, or return `null` when none is verified. */
 export function detectAndDecodeAztecRune(binaryImage) {
-  let detection;
-  try { detection = detectAztecRune(binaryImage); } catch { return null; }
-  if (!detection) return null;
-  return { ...detection.result, corners: detection.corners, moduleSize: detection.moduleSize };
+    let detection;
+    try {
+        detection = detectAztecRune(binaryImage);
+    }
+    catch {
+        return null;
+    }
+    if (!detection)
+        return null;
+    return { ...detection.result, corners: detection.corners, moduleSize: detection.moduleSize };
 }

package/src/js/aztecrune/encoder.js

@@ -27,71 +27,52 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
-/**
- * Aztec Rune encoder.
- *
- * A Rune carries exactly one byte. Numeric strings are accepted for convenient
- * human-readable input and are normalized to the canonical three-digit text;
- * binary callers can pass one byte in an ArrayBuffer or typed-array view.
- *
- * @module aztecrune/encoder
- */
-
-import { BitMatrix } from '../core/bit-matrix.js';
 import { EncodeError } from '../core/errors.js';
 import { rsEncode } from '../core/reed-solomon.js';
-import {
-  AZTEC_RUNE_DATA_POSITIONS,
-  AZTEC_RUNE_ECC_CODEWORDS,
-  AZTEC_RUNE_MASK,
-  AZTEC_RUNE_SIZE,
-  aztecRuneField,
-  buildAztecRuneStructure,
-} from './tables.js';
-
+import { AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, buildAztecRuneStructure, } from './tables.js';
 /** @param {unknown} value @returns {number} */
 export function normalizeAztecRuneValue(value) {
-  if (typeof value === 'number') {
-    if (Number.isInteger(value) && value >= 0 && value <= 255) return value;
-    throw new EncodeError('Aztec Rune: numeric value must be an integer from 0 to 255');
-  }
-
-  if (typeof value === 'string') {
-    if (!/^\d{1,3}$/.test(value)) throw new EncodeError('Aztec Rune: text input must contain one to three decimal digits');
-    const numeric = Number(value);
-    if (numeric > 255) throw new EncodeError('Aztec Rune: decimal value must be from 000 to 255');
-    return numeric;
-  }
-
-  let bytes = null;
-  if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
-  else if (ArrayBuffer.isView(value)) bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  if (bytes) {
-    if (bytes.length !== 1) throw new EncodeError('Aztec Rune: binary input must contain exactly one byte');
-    return bytes[0];
-  }
-  throw new EncodeError('Aztec Rune: expected a number, decimal string or one-byte binary value');
+    if (typeof value === 'number') {
+        if (Number.isInteger(value) && value >= 0 && value <= 255)
+            return value;
+        throw new EncodeError('Aztec Rune: numeric value must be an integer from 0 to 255');
+    }
+    if (typeof value === 'string') {
+        if (!/^\d{1,3}$/.test(value))
+            throw new EncodeError('Aztec Rune: text input must contain one to three decimal digits');
+        const numeric = Number(value);
+        if (numeric > 255)
+            throw new EncodeError('Aztec Rune: decimal value must be from 000 to 255');
+        return numeric;
+    }
+    let bytes = null;
+    if (value instanceof ArrayBuffer)
+        bytes = new Uint8Array(value);
+    else if (ArrayBuffer.isView(value))
+        bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    if (bytes) {
+        if (bytes.length !== 1)
+            throw new EncodeError('Aztec Rune: binary input must contain exactly one byte');
+        return bytes[0];
+    }
+    throw new EncodeError('Aztec Rune: expected a number, decimal string or one-byte binary value');
 }
-
 /** @param {number} value @returns {number[]} */
 function codewordsForValue(value) {
-  const data = [value >>> 4, value & 0x0f];
-  const parity = rsEncode(data, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
-  return data.concat(parity).map((word) => word ^ AZTEC_RUNE_MASK);
+    const data = [value >>> 4, value & 0x0f];
+    const parity = rsEncode(data, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
+    return data.concat(parity).map((word) => word ^ AZTEC_RUNE_MASK);
 }
-
 /** @param {BitMatrix} matrix @param {number[]} codewords */
 function writeDataRing(matrix, codewords) {
-  for (let word = 0; word < codewords.length; word++) {
-    for (let bit = 0; bit < 4; bit++) {
-      const at = word * 4 + bit;
-      const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
-      matrix.setValue(x, y, ((codewords[word] >>> (3 - bit)) & 1) !== 0);
+    for (let word = 0; word < codewords.length; word++) {
+        for (let bit = 0; bit < 4; bit++) {
+            const at = word * 4 + bit;
+            const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
+            matrix.setValue(x, y, ((codewords[word] >>> (3 - bit)) & 1) !== 0);
+        }
     }
-  }
 }
-
 /**
  * Encode one byte as an Aztec Rune.
  *
@@ -102,20 +83,21 @@ function writeDataRing(matrix, codewords) {
  * }}
  */
 export function encodeAztecRune(value, options = {}) {
-  const numeric = normalizeAztecRuneValue(value);
-  if (options.inverted !== undefined && typeof options.inverted !== 'boolean') {
-    throw new EncodeError('Aztec Rune: inverted must be boolean');
-  }
-  const inverted = options.inverted === true;
-  const matrix = buildAztecRuneStructure();
-  writeDataRing(matrix, codewordsForValue(numeric));
-  if (inverted) {
-    for (let y = 0; y < AZTEC_RUNE_SIZE; y++) for (let x = 0; x < AZTEC_RUNE_SIZE; x++) matrix.flip(x, y);
-  }
-  matrix.format = 'aztecrune';
-  matrix.value = numeric;
-  matrix.inverted = inverted;
-  return matrix;
+    const numeric = normalizeAztecRuneValue(value);
+    if (options.inverted !== undefined && typeof options.inverted !== 'boolean') {
+        throw new EncodeError('Aztec Rune: inverted must be boolean');
+    }
+    const inverted = options.inverted === true;
+    const matrix = buildAztecRuneStructure();
+    writeDataRing(matrix, codewordsForValue(numeric));
+    if (inverted) {
+        for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+            for (let x = 0; x < AZTEC_RUNE_SIZE; x++)
+                matrix.flip(x, y);
+    }
+    matrix.format = 'aztecrune';
+    matrix.value = numeric;
+    matrix.inverted = inverted;
+    return matrix;
 }
-
 export { codewordsForValue };

package/src/js/aztecrune/index.js

@@ -27,23 +27,8 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /** Aztec Rune entry points. @module aztecrune */
-
 export { encodeAztecRune, normalizeAztecRuneValue } from './encoder.js';
 export { decodeAztecRune } from './decoder.js';
 export { detectAztecRune, detectAndDecodeAztecRune } from './detector.js';
-export {
-  AZTEC_RUNE_SIZE,
-  AZTEC_RUNE_DATA_BITS,
-  AZTEC_RUNE_WORD_SIZE,
-  AZTEC_RUNE_DATA_CODEWORDS,
-  AZTEC_RUNE_ECC_CODEWORDS,
-  AZTEC_RUNE_TOTAL_CODEWORDS,
-  AZTEC_RUNE_MASK,
-  AZTEC_RUNE_DATA_POSITIONS,
-  aztecRuneStructuralValue,
-  buildAztecRuneStructure,
-  aztecRuneField,
-  validateAztecRuneTables,
-} from './tables.js';
+export { AZTEC_RUNE_SIZE, AZTEC_RUNE_DATA_BITS, AZTEC_RUNE_WORD_SIZE, AZTEC_RUNE_DATA_CODEWORDS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_TOTAL_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_DATA_POSITIONS, aztecRuneStructuralValue, buildAztecRuneStructure, aztecRuneField, validateAztecRuneTables, } from './tables.js';