@sythos/js_barcode_universal 1.2.5 → 1.4.1

package/bundle/sythos-barcode.js

@@ -1,5 +1,5 @@
 /*!
- * Sythos Barcode Suite v1.2.5
+ * Sythos Barcode Suite v1.4.1
  *
  * MIT License
  *
@@ -1823,6 +1823,413 @@ __exports.encodeMSI = encodeMSI;
 __exports.encodePharmacode = encodePharmacode;
 };
 
+__modules["oned/addons.js"] = function (__require, __exports) {
+/**
+ * UPC/EAN two- and five-digit supplements.
+ *
+ * Supplements are small symbols printed to the right of an EAN/UPC symbol.
+ * They use the ordinary EAN odd/even digit patterns, a 1011 start guard and
+ * 01 separators between digits. EAN-2 selects its parity from the numeric
+ * value modulo four. EAN-5 derives a checksum from the five digits and uses
+ * that value to select one of ten parity rows.
+ *
+ * This module intentionally keeps supplements separate from the base EAN/UPC
+ * writers. `composeEANAddon` and the `*WithAddon` helpers are opt-in; existing
+ * EAN/UPC APIs continue to return their original one-row matrices unchanged.
+ *
+ * @module oned/addons
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError, FormatError } = __require("core/errors.js");
+const { EAN_L, EAN_G } = __require("oned/patterns.js");
+const { encodeEAN13, encodeEAN8, encodeUPCA, encodeUPCE } = __require("oned/writers.js");
+
+/** EAN-2 parity rows, indexed by the two-digit value modulo four. */
+const EAN2_PARITY = Object.freeze([
+  'AA', 'AB', 'BA', 'BB',
+]);
+
+/** EAN-5 parity rows, indexed by the supplemental checksum. */
+const EAN5_PARITY = Object.freeze([
+  'BBAAA', 'BABAA', 'BAABA', 'BAAAB', 'ABBAA',
+  'AABBA', 'AAABB', 'ABABA', 'ABAAB', 'AABAB',
+]);
+
+/** Start guard used by both UPC/EAN supplemental symbols. */
+const EAN_ADDON_START = '1011';
+
+/** Separator inserted between adjacent supplemental digits. */
+const EAN_ADDON_SEPARATOR = '01';
+const EAN2_WIDTH = EAN_ADDON_START.length + 2 * 7 + EAN_ADDON_SEPARATOR.length;
+const EAN5_WIDTH = EAN_ADDON_START.length + 5 * 7 + EAN_ADDON_SEPARATOR.length * 4;
+
+/**
+ * @param {unknown} value
+ * @param {number} length
+ * @param {string} format
+ * @returns {string}
+ */
+function normalizeDigits(value, length, format) {
+  const digits = String(value);
+  if (!new RegExp(`^[0-9]{${length}}$`).test(digits)) {
+    throw new EncodeError(`${format}: payload must contain exactly ${length} digits`);
+  }
+  return digits;
+}
+
+/**
+ * EAN-5 supplemental checksum.
+ *
+ * The first, third and fifth digits carry weight three; the second and fourth
+ * carry weight nine. The checksum is not printed as a sixth digit: it selects
+ * the odd/even parity row for the five encoded digits.
+ *
+ * @param {string|number} value Five digits.
+ * @returns {number} Checksum value, 0-9.
+ */
+function ean5Checksum(value) {
+  const digits = normalizeDigits(value, 5, 'EAN-5');
+  const weighted =
+    3 * (Number(digits[0]) + Number(digits[2]) + Number(digits[4])) +
+    9 * (Number(digits[1]) + Number(digits[3]));
+  return weighted % 10;
+}
+
+/** Alias for callers that use the EAN family check-digit terminology. */
+const ean5CheckDigit = ean5Checksum;
+
+/**
+ * Resolve the EAN-2 parity row for a payload.
+ *
+ * @param {string|number} value Two digits.
+ * @returns {string} Two-character A/B parity row.
+ */
+function ean2Parity(value) {
+  const digits = normalizeDigits(value, 2, 'EAN-2');
+  return EAN2_PARITY[Number(digits) % 4];
+}
+
+/**
+ * Resolve the EAN-5 parity row for a payload.
+ *
+ * @param {string|number} value Five digits.
+ * @returns {string} Five-character A/B parity row.
+ */
+function ean5Parity(value) {
+  return EAN5_PARITY[ean5Checksum(value)];
+}
+
+/**
+ * Expand an A/B parity row into EAN digit patterns.
+ *
+ * @param {string} digits
+ * @param {string} parity
+ * @returns {string}
+ */
+function encodeDigitPatterns(digits, parity) {
+  let modules = EAN_ADDON_START;
+  for (let i = 0; i < digits.length; i++) {
+    if (i > 0) modules += EAN_ADDON_SEPARATOR;
+    const table = parity[i] === 'A' ? EAN_L : EAN_G;
+    modules += table[Number(digits[i])];
+  }
+  return modules;
+}
+
+/**
+ * Turn a module string into a one-row matrix and attach immutable source
+ * metadata for composition/rendering callers.
+ *
+ * @param {string} modules
+ * @param {{format: string, text: string, parity: string, checksum?: number}} metadata
+ * @returns {BitMatrix}
+ */
+function toAddonMatrix(modules, metadata) {
+  const matrix = new BitMatrix(modules.length, 1);
+  for (let x = 0; x < modules.length; x++) {
+    if (modules[x] === '1') matrix.set(x, 0);
+  }
+  matrix.eanAddon = Object.freeze({ ...metadata });
+  return matrix;
+}
+
+/**
+ * Encode an EAN-2 supplement.
+ *
+ * @param {string|number} value Exactly two decimal digits.
+ * @returns {BitMatrix} A 20-module, one-row supplement.
+ */
+function encodeEAN2(value) {
+  const digits = normalizeDigits(value, 2, 'EAN-2');
+  const parity = ean2Parity(digits);
+  const matrix = toAddonMatrix(encodeDigitPatterns(digits, parity), {
+    format: 'ean2',
+    text: digits,
+    parity,
+  });
+  if (matrix.width !== EAN2_WIDTH) {
+    throw new EncodeError(`EAN-2: internal width is ${matrix.width}, expected ${EAN2_WIDTH}`);
+  }
+  return matrix;
+}
+
+/**
+ * Encode an EAN-5 supplement.
+ *
+ * @param {string|number} value Exactly five decimal digits.
+ * @returns {BitMatrix} A 47-module, one-row supplement.
+ */
+function encodeEAN5(value) {
+  const digits = normalizeDigits(value, 5, 'EAN-5');
+  const checksum = ean5Checksum(digits);
+  const parity = EAN5_PARITY[checksum];
+  const matrix = toAddonMatrix(encodeDigitPatterns(digits, parity), {
+    format: 'ean5',
+    text: digits,
+    parity,
+    checksum,
+  });
+  if (matrix.width !== EAN5_WIDTH) {
+    throw new EncodeError(`EAN-5: internal width is ${matrix.width}, expected ${EAN5_WIDTH}`);
+  }
+  return matrix;
+}
+
+/**
+ * Encode either supported supplement length.
+ *
+ * @param {string|number} value Two or five decimal digits.
+ * @returns {BitMatrix}
+ */
+function encodeEANAddon(value) {
+  const digits = String(value);
+  if (digits.length === 2) return encodeEAN2(digits);
+  if (digits.length === 5) return encodeEAN5(digits);
+  throw new EncodeError('EAN add-on: payload must contain exactly two or five digits');
+}
+
+/** Alias using the spelling used by some EAN documentation. */
+const encodeEANAddOn = encodeEANAddon;
+
+/**
+ * @param {BitMatrix} matrix
+ * @param {number} offset
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+function matches(matrix, offset, pattern) {
+  if (offset < 0 || offset + pattern.length > matrix.width) return false;
+  for (let i = 0; i < pattern.length; i++) {
+    if ((matrix.get(offset + i, 0) ? '1' : '0') !== pattern[i]) return false;
+  }
+  return true;
+}
+
+/**
+ * @param {BitMatrix} matrix
+ * @param {number} start
+ * @param {2|5} digitCount
+ * @returns {{format:string,text:string,parity:string,checksum?:number,end:number}|null}
+ */
+function decodeAt(matrix, start, digitCount) {
+  const width = digitCount === 2 ? EAN2_WIDTH : EAN5_WIDTH;
+  if (!matches(matrix, start, EAN_ADDON_START)) return null;
+  if (start > 0 && matrix.get(start - 1, 0)) return null;
+
+  let offset = start + EAN_ADDON_START.length;
+  let text = '';
+  let parity = '';
+
+  for (let i = 0; i < digitCount; i++) {
+    let found = null;
+    for (let digit = 0; digit < 10; digit++) {
+      for (const [letter, table] of [['A', EAN_L], ['B', EAN_G]]) {
+        if (matches(matrix, offset, table[digit]) &&
+            (!found || found.letter !== letter || found.digit !== digit)) {
+          if (found) return null;
+          found = { digit, letter };
+        }
+      }
+    }
+    if (!found) return null;
+    text += String(found.digit);
+    parity += found.letter;
+    offset += 7;
+    if (i < digitCount - 1) {
+      if (!matches(matrix, offset, EAN_ADDON_SEPARATOR)) return null;
+      offset += EAN_ADDON_SEPARATOR.length;
+    }
+  }
+
+  if (offset - start !== width) return null;
+  if (digitCount === 2) {
+    if (EAN2_PARITY[Number(text) % 4] !== parity) return null;
+    return { format: 'ean2', text, parity, end: offset };
+  }
+
+  const checksum = ean5Checksum(text);
+  if (EAN5_PARITY[checksum] !== parity) return null;
+  return { format: 'ean5', text, parity, checksum, end: offset };
+}
+
+/**
+ * Validate and decode an EAN-2 supplement. A leading quiet zone is accepted;
+ * the decoder searches the row for a valid start guard so a composed base
+ * EAN/UPC matrix can be passed directly as well.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean2',text:string,parity:string}}
+ * @throws {FormatError} When no valid supplement is found.
+ */
+function decodeEAN2(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || matrix.height !== 1) {
+    throw new FormatError('EAN-2: expected a one-row module matrix');
+  }
+  for (let start = 0; start + EAN2_WIDTH <= matrix.width; start++) {
+    const result = decodeAt(matrix, start, 2);
+    if (result) {
+      const { end, ...publicResult } = result;
+      void end;
+      return publicResult;
+    }
+  }
+  throw new FormatError('EAN-2: start, parity or digit pattern is invalid');
+}
+
+/**
+ * Validate and decode an EAN-5 supplement.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean5',text:string,parity:string,checksum:number}}
+ * @throws {FormatError} When no valid supplement is found.
+ */
+function decodeEAN5(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || matrix.height !== 1) {
+    throw new FormatError('EAN-5: expected a one-row module matrix');
+  }
+  for (let start = 0; start + EAN5_WIDTH <= matrix.width; start++) {
+    const result = decodeAt(matrix, start, 5);
+    if (result) {
+      const { end, ...publicResult } = result;
+      void end;
+      return publicResult;
+    }
+  }
+  throw new FormatError('EAN-5: start, parity, checksum or digit pattern is invalid');
+}
+
+/**
+ * Decode either supported supplement length.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean2'|'ean5',text:string,parity:string,checksum?:number}}
+ * @throws {FormatError} When neither supplement grammar matches.
+ */
+function decodeEANAddon(matrix) {
+  try {
+    return decodeEAN5(matrix);
+  } catch (fiveError) {
+    try {
+      return decodeEAN2(matrix);
+    } catch (twoError) {
+      throw new FormatError(`EAN add-on: ${fiveError.message}; ${twoError.message}`);
+    }
+  }
+}
+
+/** Alias using the spelling used by some EAN documentation. */
+const decodeEANAddOn = decodeEANAddon;
+
+/**
+ * Join a base EAN/UPC matrix and a supplement with the standard quiet gap.
+ *
+ * The helper does not alter either input. By default it inserts nine light
+ * modules, the conventional separation between the base symbol and an add-on.
+ * The result carries the supplement metadata under `eanAddon` for renderers or
+ * callers that need to label the composed symbol.
+ *
+ * @param {BitMatrix} base Base EAN/UPC matrix.
+ * @param {BitMatrix|string|number} addon Add-on matrix or two/five digits.
+ * @param {{gap?:number}} [options]
+ * @returns {BitMatrix}
+ */
+function composeEANAddon(base, addon, options = {}) {
+  if (!base || !Number.isInteger(base.width) || base.height !== 1) {
+    throw new TypeError('EAN add-on: base must be a one-row module matrix');
+  }
+  const addonMatrix = typeof addon === 'string' || typeof addon === 'number'
+    ? encodeEANAddon(addon)
+    : addon;
+  if (!addonMatrix || !Number.isInteger(addonMatrix.width) || addonMatrix.height !== 1) {
+    throw new TypeError('EAN add-on: supplement must be a one-row module matrix or digits');
+  }
+
+  const gap = options.gap === undefined ? 9 : Number(options.gap);
+  if (!Number.isInteger(gap) || gap < 1) {
+    throw new EncodeError(`EAN add-on: gap must be a positive integer, got ${options.gap}`);
+  }
+
+  const result = new BitMatrix(base.width + gap + addonMatrix.width, 1);
+  for (let x = 0; x < base.width; x++) if (base.get(x, 0)) result.set(x, 0);
+  for (let x = 0; x < addonMatrix.width; x++) {
+    if (addonMatrix.get(x, 0)) result.set(base.width + gap + x, 0);
+  }
+  if (addonMatrix.eanAddon) result.eanAddon = { ...addonMatrix.eanAddon, gap };
+  return result;
+}
+
+/**
+ * Compose an EAN-13 symbol with an EAN-2 or EAN-5 supplement.
+ *
+ * @param {string} value Base EAN-13 payload.
+ * @param {string|number} addon Two or five supplemental digits.
+ * @param {{gap?:number}} [options]
+ * @returns {BitMatrix}
+ */
+function encodeEAN13WithAddon(value, addon, options = {}) {
+  return composeEANAddon(encodeEAN13(value), addon, options);
+}
+
+/** @see encodeEAN13WithAddon */
+function encodeEAN8WithAddon(value, addon, options = {}) {
+  return composeEANAddon(encodeEAN8(value), addon, options);
+}
+
+/** @see encodeEAN13WithAddon */
+function encodeUPCAWithAddon(value, addon, options = {}) {
+  return composeEANAddon(encodeUPCA(value), addon, options);
+}
+
+/** @see encodeEAN13WithAddon */
+function encodeUPCEWithAddon(value, addon, options = {}) {
+  return composeEANAddon(encodeUPCE(value), addon, options);
+}
+
+__exports.EAN2_PARITY = EAN2_PARITY;
+__exports.EAN5_PARITY = EAN5_PARITY;
+__exports.EAN_ADDON_START = EAN_ADDON_START;
+__exports.EAN_ADDON_SEPARATOR = EAN_ADDON_SEPARATOR;
+__exports.EAN2_WIDTH = EAN2_WIDTH;
+__exports.EAN5_WIDTH = EAN5_WIDTH;
+__exports.ean5Checksum = ean5Checksum;
+__exports.ean5CheckDigit = ean5CheckDigit;
+__exports.ean2Parity = ean2Parity;
+__exports.ean5Parity = ean5Parity;
+__exports.encodeEAN2 = encodeEAN2;
+__exports.encodeEAN5 = encodeEAN5;
+__exports.encodeEANAddon = encodeEANAddon;
+__exports.encodeEANAddOn = encodeEANAddOn;
+__exports.decodeEAN2 = decodeEAN2;
+__exports.decodeEAN5 = decodeEAN5;
+__exports.decodeEANAddon = decodeEANAddon;
+__exports.decodeEANAddOn = decodeEANAddOn;
+__exports.composeEANAddon = composeEANAddon;
+__exports.encodeEAN13WithAddon = encodeEAN13WithAddon;
+__exports.encodeEAN8WithAddon = encodeEAN8WithAddon;
+__exports.encodeUPCAWithAddon = encodeUPCAWithAddon;
+__exports.encodeUPCEWithAddon = encodeUPCEWithAddon;
+};
+
 __modules["oned/reader.js"] = function (__require, __exports) {
 /**
  * Linear barcode reading.
@@ -2716,7 +3123,10 @@ __modules["oned/index.js"] = function (__require, __exports) {
  * Linear symbologies.
  *
  * @module oned
- */
+ */
+const __reexport1 = __require("oned/addons.js"); __exports.EAN2_PARITY = __reexport1.EAN2_PARITY; __exports.EAN5_PARITY = __reexport1.EAN5_PARITY; __exports.EAN2_WIDTH = __reexport1.EAN2_WIDTH; __exports.EAN5_WIDTH = __reexport1.EAN5_WIDTH; __exports.EAN_ADDON_START = __reexport1.EAN_ADDON_START; __exports.EAN_ADDON_SEPARATOR = __reexport1.EAN_ADDON_SEPARATOR; __exports.ean2Parity = __reexport1.ean2Parity; __exports.ean5Checksum = __reexport1.ean5Checksum; __exports.ean5CheckDigit = __reexport1.ean5CheckDigit; __exports.ean5Parity = __reexport1.ean5Parity; __exports.encodeEAN2 = __reexport1.encodeEAN2; __exports.encodeEAN5 = __reexport1.encodeEAN5; __exports.encodeEANAddon = __reexport1.encodeEANAddon; __exports.encodeEANAddOn = __reexport1.encodeEANAddOn; __exports.decodeEAN2 = __reexport1.decodeEAN2; __exports.decodeEAN5 = __reexport1.decodeEAN5; __exports.decodeEANAddon = __reexport1.decodeEANAddon; __exports.decodeEANAddOn = __reexport1.decodeEANAddOn; __exports.composeEANAddon = __reexport1.composeEANAddon; __exports.encodeEAN13WithAddon = __reexport1.encodeEAN13WithAddon; __exports.encodeEAN8WithAddon = __reexport1.encodeEAN8WithAddon; __exports.encodeUPCAWithAddon = __reexport1.encodeUPCAWithAddon; __exports.encodeUPCEWithAddon = __reexport1.encodeUPCEWithAddon;
+const __reexport2 = __require("oned/reader.js"); __exports.decodeOneD = __reexport2.decodeOneD; __exports.decodeOneDStrict = __reexport2.decodeOneDStrict; __exports.patternVariance = __reexport2.patternVariance; __exports.recordPattern = __reexport2.recordPattern; __exports.toNarrowWidePattern = __reexport2.toNarrowWidePattern;
+const { encodeEAN2, encodeEAN5 } = __require("oned/addons.js");
 
 /**
  * Writers by format id, for the top-level `encode()` dispatcher.
@@ -2727,7 +3137,7 @@ __modules["oned/index.js"] = function (__require, __exports) {
  * failing at runtime.
  *
  * @type {Record<string, {encode: Function, readable: boolean, label: string}>}
- */
+ */
   ean13: { encode: encodeEAN13, readable: true, label: 'EAN-13' },
   ean8: { encode: encodeEAN8, readable: true, label: 'EAN-8' },
   upca: { encode: encodeUPCA, readable: true, label: 'UPC-A' },
@@ -2746,8 +3156,13 @@ __modules["oned/index.js"] = function (__require, __exports) {
   codabar: { encode: encodeCodabar, readable: true, label: 'Codabar' },
   code11: { encode: encodeCode11, readable: false, label: 'Code 11' },
   msi: { encode: encodeMSI, readable: false, label: 'MSI Plessey' },
-  pharmacode: { encode: encodePharmacode, readable: false, label: 'Pharmacode' },
-};
+  pharmacode: { encode: encodePharmacode, readable: false, label: 'Pharmacode' },
+  // Supplements are writable standalone matrices, but their reader is
+  // intentionally exposed through the EAN/UPC add-on helpers rather than the
+  // generic one-dimensional scan pipeline.
+  ean2: { encode: encodeEAN2, readable: false, label: 'EAN-2 supplement' },
+  ean5: { encode: encodeEAN5, readable: false, label: 'EAN-5 supplement' },
+};
 
 __exports.ONED_FORMATS = ONED_FORMATS;
 };
@@ -10255,90 +10670,4028 @@ const __reexport5 = __require("micropdf417/detector.js"); __exports.detectMicroP
 
 };
 
-__modules["render/options.js"] = function (__require, __exports) {
+__modules["microqr/tables.js"] = function (__require, __exports) {
 /**
- * Shared render options, normalised once so every backend agrees.
+ * Micro QR Code structural facts and geometry.
  *
- * @module render/options
+ * Only the irreducible public symbology values are tabulated. Grid capacity,
+ * reserved areas and placement order are derived independently and checked by
+ * {@link validateMicroQrTables}. M1 and M3 have a four-bit final data symbol
+ * character; `dataBits` therefore is authoritative and must not be inferred as
+ * `dataCodewords * 8` for those versions.
+ *
+ * @module microqr/tables
  */
 const { BitMatrix } = __require("core/bit-matrix.js");
 
-/**
- * @typedef {object} RenderOptions
- * @property {number} [scale] Pixels per module. Default 8.
- * @property {number} [margin] Quiet-zone modules on every side. Default 4.
- * @property {string} [dark] Colour of set modules. Default '#000000'.
- * @property {string} [light] Colour of clear modules, or 'none' for transparent.
- * @property {number} [barHeight] For 1D symbols: total bar height in pixels.
- */
+/** Numeric version identifiers used by the encoder selection loop. */
+const MICROQR_VERSIONS = Object.freeze([1, 2, 3, 4]);
+const MICROQR_VERSION_NAMES = Object.freeze(['M1', 'M2', 'M3', 'M4']);
+const MICROQR_ECC_LEVELS = Object.freeze(['DETECT', 'L', 'M', 'Q']);
+const MICROQR_FORMAT_MASK = 0x4445;
+const MICROQR_FORMAT_GENERATOR = 0x537;
+
+const symbol = (version, ecc, symbolNumber, totalCodewords, dataCodewords, dataBits, eccCodewords) => Object.freeze({
+  version,
+  ecc,
+  symbolNumber,
+  size: 9 + Number(version.slice(1)) * 2,
+  totalCodewords,
+  dataCodewords,
+  dataBits,
+  eccCodewords,
+  blockCount: 1,
+  shortDataCodewordBits: dataBits % 8 || 8,
+  remainderBits: 0,
+});
+
+/** The eight legal Micro QR version/error-correction combinations. */
+const MICROQR_SYMBOLS = Object.freeze([
+  symbol('M1', 'DETECT', 0, 5, 3, 20, 2),
+  symbol('M2', 'L',      1, 10, 5, 40, 5),
+  symbol('M2', 'M',      2, 10, 4, 32, 6),
+  symbol('M3', 'L',      3, 17, 11, 84, 6),
+  symbol('M3', 'M',      4, 17, 9, 68, 8),
+  symbol('M4', 'L',      5, 24, 16, 128, 8),
+  symbol('M4', 'M',      6, 24, 14, 112, 10),
+  symbol('M4', 'Q',      7, 24, 10, 80, 14),
+]);
+
+const symbolByKey = new Map(MICROQR_SYMBOLS.map((entry) => [`${entry.version}:${entry.ecc}`, entry]));
+const symbolByNumber = new Map(MICROQR_SYMBOLS.map((entry) => [entry.symbolNumber, entry]));
+
+function canonicalVersion(version) {
+  const result = typeof version === 'number' ? `M${version}` : String(version).toUpperCase();
+  if (!MICROQR_VERSION_NAMES.includes(result)) throw new RangeError(`Micro QR: version must be M1-M4, got ${version}`);
+  return result;
+}
+
+/** @param {string|number} version @returns {number} */
+function microQrVersionSize(version) {
+  return 9 + Number(canonicalVersion(version).slice(1)) * 2;
+}
+
+/** Resolve the format symbol number for a legal version/ECC pair. */
+function microQrSymbolNumber(version, ecc) {
+  return microQrBlockLayout(version, ecc).symbolNumber;
+}
+
+/** Resolve the immutable single-block layout for a legal version/ECC pair. */
+function microQrBlockLayout(version, ecc) {
+  const canonical = canonicalVersion(version);
+  const level = ecc == null && canonical === 'M1' ? 'DETECT' : String(ecc).toUpperCase();
+  const entry = symbolByKey.get(`${canonical}:${level}`);
+  if (!entry) throw new RangeError(`Micro QR: error correction level ${ecc} is not valid for ${canonical}`);
+  return entry;
+}
+
+/** @returns {number} Usable message bits, including mode/count overhead. */
+function microQrDataCapacityBits(version, ecc) {
+  return microQrBlockLayout(version, ecc).dataBits;
+}
 
 /**
- * Expand and pad the matrix, and resolve every dimension.
- *
- * Linear symbols arrive one module tall. They are stretched to `barHeight`
- * *before* the quiet zone is applied, so the margin ends up uniform on all
- * four sides — padding first would leave a quiet zone one module tall against
- * bars a hundred pixels tall, which no scanner would accept.
- *
- * @param {BitMatrix} matrix
- * @param {RenderOptions} options
+ * Encode the five format data bits with BCH(15,5), then apply the Micro QR
+ * format mask. `symbolNumber` occupies the high three data bits and `mask`
+ * the low two.
  */
-function normalizeOptions(matrix, options = {}) {
-  const scale = Math.max(1, Math.floor(options.scale ?? 8));
-  const margin = Math.max(0, Math.floor(options.margin ?? 4));
-  const dark = options.dark ?? '#000000';
-  const light = options.light ?? '#ffffff';
-  const barHeight = options.barHeight ?? null;
+function microQrFormatInfo(symbolNumber, mask, maybeMask) {
+  // Public convenience overload: (version, ecc, mask).
+  if (arguments.length === 3) {
+    symbolNumber = microQrSymbolNumber(symbolNumber, mask);
+    mask = maybeMask;
+  }
+  if (!Number.isInteger(symbolNumber) || symbolNumber < 0 || symbolNumber > 7) {
+    throw new RangeError('Micro QR: symbol number must be an integer in 0..7');
+  }
+  if (!Number.isInteger(mask) || mask < 0 || mask > 3) {
+    throw new RangeError('Micro QR: mask must be an integer in 0..3');
+  }
+  const data = (symbolNumber << 2) | mask;
+  let remainder = data << 10;
+  for (let bit = 14; bit >= 10; bit--) {
+    if ((remainder & (1 << bit)) !== 0) remainder ^= MICROQR_FORMAT_GENERATOR << (bit - 10);
+  }
+  return ((data << 10) | remainder) ^ MICROQR_FORMAT_MASK;
+}
 
-  let base = matrix;
-  const is1D = matrix.height === 1;
+function hammingDistance(a, b) {
+  let bits = (a ^ b) & 0x7fff;
+  let count = 0;
+  while (bits) { bits &= bits - 1; count++; }
+  return count;
+}
 
-  if (is1D) {
-    // Default to a bar height that stays scannable: tall enough that a laser
-    // crossing at a slight angle still passes through the whole symbol.
-    const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
-    const rows = Math.max(1, Math.round(targetPixels / scale));
-    base = new BitMatrix(matrix.width, rows);
-    for (let x = 0; x < matrix.width; x++) {
-      if (!matrix.get(x, 0)) continue;
-      for (let y = 0; y < rows; y++) base.set(x, y);
+/** Decode/correct a 15-bit format word. Returns null beyond three errors. */
+function microQrDecodeFormatInfo(bits) {
+  if (!Number.isInteger(bits) || bits < 0 || bits > 0x7fff) {
+    throw new RangeError('Micro QR: format information must be a 15-bit integer');
+  }
+  let best = null;
+  let bestDistance = 16;
+  for (const entry of MICROQR_SYMBOLS) for (let mask = 0; mask < 4; mask++) {
+    const expected = microQrFormatInfo(entry.symbolNumber, mask);
+    const distance = hammingDistance(bits, expected);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = { version: entry.version, ecc: entry.ecc, symbolNumber: entry.symbolNumber, mask, correctedBits: distance, bits: expected };
     }
   }
+  return bestDistance <= 3 ? best : null;
+}
 
-  const source = margin > 0 ? base.withMargin(margin) : base;
-
-  return {
-    scale,
-    margin,
-    dark,
-    light,
-    is1D,
-    source,
-    rowHeight: scale,
-    pixelWidth: source.width * scale,
-    pixelHeight: source.height * scale,
-  };
+/**
+ * Format modules in bit-number order, least significant bit first. Bits 0..7
+ * run down column 8; bits 8..14 continue right-to-left along row 8.
+ * Position (8,8) is shared by the two arms and appears once.
+ */
+function microQrFormatInfoPositions(sizeOrVersion) {
+  const size = typeof sizeOrVersion === 'number' && sizeOrVersion >= 11
+    ? sizeOrVersion
+    : microQrVersionSize(sizeOrVersion);
+  if (![11, 13, 15, 17].includes(size)) throw new RangeError(`Micro QR: invalid symbol size ${size}`);
+  const positions = [];
+  for (let y = 1; y <= 8; y++) positions.push([8, y]);
+  for (let x = 7; x >= 1; x--) positions.push([x, 8]);
+  return positions;
 }
 
+const reservedCache = new Map();
+const functionCache = new Map();
+
 /**
- * Parse a CSS colour into RGBA bytes.
- *
- * Supports the forms a barcode actually needs: #rgb, #rgba, #rrggbb,
- * #rrggbbaa, rgb(), rgba(), plus 'none' and 'transparent'.
- *
- * @param {string} colour
- * @returns {[number, number, number, number]}
+ * Fixed dark function modules before format information is written. Light
+ * separator and light timing modules remain unset; use
+ * {@link microQrReservedModules} to distinguish them from payload modules.
  */
-function parseColor(colour) {
-  const value = String(colour).trim().toLowerCase();
+function microQrFunctionModules(version) {
+  const canonical = canonicalVersion(version);
+  const cached = functionCache.get(canonical);
+  if (cached) return cached;
+  const size = microQrVersionSize(canonical);
+  const matrix = new BitMatrix(size, size);
+  for (let y = 0; y < 7; y++) for (let x = 0; x < 7; x++) {
+    const outer = x === 0 || x === 6 || y === 0 || y === 6;
+    const centre = x >= 2 && x <= 4 && y >= 2 && y <= 4;
+    if (outer || centre) matrix.set(x, y);
+  }
+  for (let coordinate = 8; coordinate < size; coordinate += 2) {
+    matrix.set(coordinate, 0);
+    matrix.set(0, coordinate);
+  }
+  functionCache.set(canonical, matrix);
+  return matrix;
+}
 
-  if (value === 'none' || value === 'transparent') return [0, 0, 0, 0];
-  if (value === 'white') return [255, 255, 255, 255];
-  if (value === 'black') return [0, 0, 0, 255];
+/** Shared immutable-in-use map of finder, separator, timing and format modules. */
+function microQrReservedModules(version) {
+  const canonical = canonicalVersion(version);
+  const cached = reservedCache.get(canonical);
+  if (cached) return cached;
+  const size = microQrVersionSize(canonical);
+  const matrix = new BitMatrix(size, size);
+  matrix.setRegion(0, 0, 8, 8); // 7x7 finder plus inner separator
+  for (let coordinate = 8; coordinate < size; coordinate++) {
+    matrix.set(coordinate, 0); // horizontal timing
+    matrix.set(0, coordinate); // vertical timing
+  }
+  for (const [x, y] of microQrFormatInfoPositions(size)) matrix.set(x, y);
+  reservedCache.set(canonical, matrix);
+  return matrix;
+}
 
-  if (value[0] === '#') {
-    const hex = value.slice(1);
-    const expand = (c) => parseInt(c + c, 16);
+/** Number of modules carrying data or error-correction bits. */
+function microQrFreeModuleCount(version) {
+  const size = microQrVersionSize(version);
+  const reserved = microQrReservedModules(version);
+  let count = 0;
+  for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+    if (!reserved.get(x, y)) count++;
+  }
+  return count;
+}
+
+const orderCache = new Map();
+
+/** Payload module coordinates as interleaved x,y pairs, MSB-first stream order. */
+function microQrDataModuleOrder(version) {
+  const canonical = canonicalVersion(version);
+  const cached = orderCache.get(canonical);
+  if (cached) return cached;
+  const size = microQrVersionSize(canonical);
+  const reserved = microQrReservedModules(canonical);
+  const order = new Int32Array(microQrFreeModuleCount(canonical) * 2);
+  let offset = 0;
+  let upward = true;
+  for (let column = size - 1; column > 0; column -= 2) {
+    for (let rowOffset = 0; rowOffset < size; rowOffset++) {
+      const y = upward ? size - 1 - rowOffset : rowOffset;
+      for (let side = 0; side < 2; side++) {
+        const x = column - side;
+        if (reserved.get(x, y)) continue;
+        order[offset++] = x;
+        order[offset++] = y;
+      }
+    }
+    upward = !upward;
+  }
+  orderCache.set(canonical, order);
+  return order;
+}
+
+/** The four Micro QR data-mask predicates. */
+function microQrMaskBit(mask, x, y) {
+  switch (mask) {
+    case 0: return (y & 1) === 0;
+    case 1: return (((y >> 1) + Math.floor(x / 3)) & 1) === 0;
+    case 2: return ((((y * x) & 1) + ((y * x) % 3)) & 1) === 0;
+    case 3: return ((((y + x) & 1) + ((y * x) % 3)) & 1) === 0;
+    default: throw new RangeError(`Micro QR: mask must be an integer in 0..3, got ${mask}`);
+  }
+}
+
+/** Return all internal table/geometry invariant failures. */
+function validateMicroQrTables() {
+  const issues = [];
+  if (MICROQR_SYMBOLS.length !== 8) issues.push('expected eight symbol/ECC combinations');
+  const numbers = new Set();
+  for (const entry of MICROQR_SYMBOLS) {
+    const tag = `${entry.version}-${entry.ecc}`;
+    if (numbers.has(entry.symbolNumber)) issues.push(`${tag}: duplicate symbol number`);
+    numbers.add(entry.symbolNumber);
+    if (entry.blockCount !== 1) issues.push(`${tag}: Micro QR must use one block`);
+    if (entry.dataBits + entry.eccCodewords * 8 !== microQrFreeModuleCount(entry.version)) {
+      issues.push(`${tag}: data/ECC bits do not fill the encoding region`);
+    }
+    if (entry.totalCodewords !== entry.dataCodewords + entry.eccCodewords) issues.push(`${tag}: codeword count mismatch`);
+    if (entry.dataBits !== (entry.dataCodewords - 1) * 8 + entry.shortDataCodewordBits) issues.push(`${tag}: final data codeword mismatch`);
+    if (entry.shortDataCodewordBits !== (entry.version === 'M1' || entry.version === 'M3' ? 4 : 8)) issues.push(`${tag}: wrong final data codeword width`);
+  }
+  for (const version of MICROQR_VERSIONS) {
+    const size = microQrVersionSize(version);
+    const positions = microQrFormatInfoPositions(size);
+    const unique = new Set(positions.map(([x, y]) => `${x},${y}`));
+    if (positions.length !== 15 || unique.size !== 15) issues.push(`${version}: format positions must be 15 unique modules`);
+    const order = microQrDataModuleOrder(version);
+    const orderUnique = new Set();
+    for (let i = 0; i < order.length; i += 2) {
+      const x = order[i], y = order[i + 1];
+      if (microQrReservedModules(version).get(x, y)) issues.push(`${version}: placement enters reserved module ${x},${y}`);
+      orderUnique.add(`${x},${y}`);
+    }
+    if (orderUnique.size * 2 !== order.length) issues.push(`${version}: placement repeats a module`);
+    if (order.length !== microQrFreeModuleCount(version) * 2) issues.push(`${version}: placement does not cover encoding region`);
+    const functions = microQrFunctionModules(version);
+    for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+      if (functions.get(x, y) && !microQrReservedModules(version).get(x, y)) {
+        issues.push(`${version}: dark function module ${x},${y} is not reserved`);
+      }
+    }
+  }
+  for (const entry of MICROQR_SYMBOLS) for (let mask = 0; mask < 4; mask++) {
+    const decoded = microQrDecodeFormatInfo(microQrFormatInfo(entry.symbolNumber, mask));
+    if (!decoded || decoded.symbolNumber !== entry.symbolNumber || decoded.mask !== mask || decoded.correctedBits !== 0) {
+      issues.push(`${entry.version}-${entry.ecc}: format round-trip failed for mask ${mask}`);
+    }
+  }
+  return issues;
+}
+
+__exports.MICROQR_VERSIONS = MICROQR_VERSIONS;
+__exports.MICROQR_VERSION_NAMES = MICROQR_VERSION_NAMES;
+__exports.MICROQR_ECC_LEVELS = MICROQR_ECC_LEVELS;
+__exports.MICROQR_FORMAT_MASK = MICROQR_FORMAT_MASK;
+__exports.MICROQR_FORMAT_GENERATOR = MICROQR_FORMAT_GENERATOR;
+__exports.MICROQR_SYMBOLS = MICROQR_SYMBOLS;
+__exports.microQrVersionSize = microQrVersionSize;
+__exports.microQrSymbolNumber = microQrSymbolNumber;
+__exports.microQrBlockLayout = microQrBlockLayout;
+__exports.microQrDataCapacityBits = microQrDataCapacityBits;
+__exports.microQrFormatInfo = microQrFormatInfo;
+__exports.microQrDecodeFormatInfo = microQrDecodeFormatInfo;
+__exports.microQrFormatInfoPositions = microQrFormatInfoPositions;
+__exports.microQrFunctionModules = microQrFunctionModules;
+__exports.microQrReservedModules = microQrReservedModules;
+__exports.microQrFreeModuleCount = microQrFreeModuleCount;
+__exports.microQrDataModuleOrder = microQrDataModuleOrder;
+__exports.microQrMaskBit = microQrMaskBit;
+__exports.validateMicroQrTables = validateMicroQrTables;
+};
+
+__modules["microqr/encoder.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { BitWriter } = __require("core/bit-buffer.js");
+const { EncodeError } = __require("core/errors.js");
+const { GF256_QR } = __require("core/galois-field.js");
+const { rsEncode } = __require("core/reed-solomon.js");
+const { MICROQR_VERSIONS, microQrBlockLayout, microQrDataModuleOrder, microQrFormatInfo, microQrFormatInfoPositions, microQrMaskBit, microQrSymbolNumber, microQrVersionSize } = __require("microqr/tables.js");
+const MICROQR_ALPHANUMERIC = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+const MODE = { numeric: 0, alphanumeric: 1, byte: 2, kanji: 3 };
+const MODE_MIN_VERSION = { numeric: 1, alphanumeric: 2, byte: 3, kanji: 3 };
+const COUNT_BITS = {
+  numeric: [0, 3, 4, 5, 6], alphanumeric: [0, 0, 3, 4, 5],
+  byte: [0, 0, 0, 4, 5], kanji: [0, 0, 0, 3, 4],
+};
+
+function parseVersion(value) {
+  if (value == null) return null;
+  const match = /^M?([1-4])$/i.exec(String(value));
+  if (!match) throw new EncodeError(`Micro QR: version must be M1-M4, got ${value}`);
+  return Number(match[1]);
+}
+
+function versionNumber(version) {
+  return typeof version === 'number' ? version : Number(String(version).slice(1));
+}
+
+function latin1Bytes(text) {
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) {
+    const cp = text.charCodeAt(i);
+    if (cp > 0xff) throw new EncodeError('Micro QR: byte mode supports ISO-8859-1 only (ECI is unavailable)');
+    bytes[i] = cp;
+  }
+  return bytes;
+}
+
+let sjisReverseMap;
+
+function sjisToThirteenBits(sjis) {
+  const trail = sjis & 0xff;
+  if (trail < 0x40 || trail === 0x7f || trail > 0xfc) return -1;
+  let adjusted;
+  if (sjis >= 0x8140 && sjis <= 0x9ffc) adjusted = sjis - 0x8140;
+  else if (sjis >= 0xe040 && sjis <= 0xebbf) adjusted = sjis - 0xc140;
+  else return -1;
+  const packed = (adjusted >>> 8) * 0xc0 + (adjusted & 0xff);
+  return packed <= 0x1fff ? packed : -1;
+}
+
+function getSjisReverseMap() {
+  if (sjisReverseMap !== undefined) return sjisReverseMap;
+  let decoder;
+  try {
+    decoder = new TextDecoder('shift_jis', { fatal: true });
+    if (decoder.decode(new Uint8Array([0x82, 0xa0])) !== 'あ') return (sjisReverseMap = null);
+  } catch {
+    return (sjisReverseMap = null);
+  }
+  const result = new Map();
+  const bytes = new Uint8Array(2);
+  for (const [start, end] of [[0x8140, 0x9ffc], [0xe040, 0xebbf]]) {
+    for (let value = start; value <= end; value++) {
+      if (sjisToThirteenBits(value) < 0) continue;
+      bytes[0] = value >>> 8;
+      bytes[1] = value & 0xff;
+      let character;
+      try { character = decoder.decode(bytes); } catch { continue; }
+      if (Array.from(character).length === 1 && !result.has(character)) result.set(character, value);
+    }
+  }
+  sjisReverseMap = result;
+  return result;
+}
+
+function kanjiValues(text) {
+  const reverse = getSjisReverseMap();
+  if (!reverse) return null;
+  const values = [];
+  for (const character of text) {
+    const sjis = reverse.get(character);
+    if (sjis == null) return null;
+    values.push(sjisToThirteenBits(sjis));
+  }
+  return values;
+}
+
+function chooseMode(text, forced) {
+  const mode = forced == null ? (/^\d+$/.test(text) ? 'numeric' :
+    [...text].every((ch) => MICROQR_ALPHANUMERIC.includes(ch)) ? 'alphanumeric' :
+      kanjiValues(text) ? 'kanji' : 'byte') :
+    String(forced).toLowerCase();
+  if (!(mode in MODE)) throw new EncodeError(`Micro QR: unsupported mode "${forced}"`);
+  if (mode === 'numeric' && !/^\d+$/.test(text)) throw new EncodeError('Micro QR: numeric mode accepts digits only');
+  if (mode === 'alphanumeric' && ![...text].every((ch) => MICROQR_ALPHANUMERIC.includes(ch))) {
+    throw new EncodeError('Micro QR: alphanumeric mode contains an unsupported character');
+  }
+  if (mode === 'kanji' && !kanjiValues(text)) {
+    throw new EncodeError('Micro QR: kanji mode requires characters representable in the QR Shift_JIS ranges');
+  }
+  return mode;
+}
+
+function encodePayload(text, mode) {
+  const w = new BitWriter();
+  if (mode === 'numeric') {
+    for (let i = 0; i < text.length; i += 3) {
+      const n = Math.min(3, text.length - i);
+      w.put(Number(text.slice(i, i + n)), n === 3 ? 10 : n === 2 ? 7 : 4);
+    }
+  } else if (mode === 'alphanumeric') {
+    let i = 0;
+    for (; i + 1 < text.length; i += 2) {
+      w.put(MICROQR_ALPHANUMERIC.indexOf(text[i]) * 45 + MICROQR_ALPHANUMERIC.indexOf(text[i + 1]), 11);
+    }
+    if (i < text.length) w.put(MICROQR_ALPHANUMERIC.indexOf(text[i]), 6);
+  } else if (mode === 'byte') {
+    w.putBytes(latin1Bytes(text));
+  } else {
+    for (const value of kanjiValues(text)) w.put(value, 13);
+  }
+  return w;
+}
+
+function getBit(writer, index) {
+  return ((writer.bytes[index >>> 3] >>> (7 - (index & 7))) & 1) === 1;
+}
+
+function writeData(text, mode, version, layout) {
+  const numericVersion = versionNumber(version);
+  const payload = encodePayload(text, mode);
+  const writer = new BitWriter();
+  if (numericVersion > 1) writer.put(MODE[mode], numericVersion - 1);
+  const count = mode === 'byte' ? latin1Bytes(text).length : [...text].length;
+  const countWidth = COUNT_BITS[mode][numericVersion];
+  if (countWidth === 0 || count >= 2 ** countWidth) return null;
+  writer.put(count, countWidth);
+  for (let i = 0; i < payload.length; i++) writer.putBit(getBit(payload, i));
+  if (writer.length > layout.dataBits) return null;
+  for (let i = 0, n = Math.min(2 * numericVersion + 1, layout.dataBits - writer.length); i < n; i++) writer.putBit(false);
+  if (numericVersion !== 1 && numericVersion !== 3) {
+    while ((writer.length & 7) && writer.length < layout.dataBits) writer.putBit(false);
+  }
+  if (numericVersion === 1 || numericVersion === 3) {
+    while (writer.length < layout.dataBits) writer.putBit(false);
+    return writer;
+  }
+  let pad = 0;
+  while (writer.length + 8 <= layout.dataBits) writer.put(pad++ & 1 ? 0x11 : 0xec, 8);
+  while (writer.length < layout.dataBits) writer.putBit(false);
+  return writer;
+}
+
+function finalMessage(dataWriter, layout) {
+  const bytes = Array.from(dataWriter.toBytes());
+  if (layout.shortDataCodewordBits === 4) bytes[bytes.length - 1] &= 0xf0;
+  const ecc = rsEncode(bytes, layout.eccCodewords, GF256_QR, 0);
+  const out = [];
+  const full = layout.shortDataCodewordBits === 4 ? bytes.length - 1 : bytes.length;
+  for (let i = 0; i < full; i++) for (let b = 7; b >= 0; b--) out.push((bytes[i] >>> b) & 1);
+  if (layout.shortDataCodewordBits === 4) for (let b = 7; b >= 4; b--) out.push((bytes[bytes.length - 1] >>> b) & 1);
+  for (const value of ecc) for (let b = 7; b >= 0; b--) out.push((value >>> b) & 1);
+  return out;
+}
+
+function drawFunctions(matrix) {
+  const size = matrix.width;
+  for (let y = 0; y < 7; y++) for (let x = 0; x < 7; x++) {
+    const ring = x === 0 || x === 6 || y === 0 || y === 6;
+    const core = x >= 2 && x <= 4 && y >= 2 && y <= 4;
+    matrix.setValue(x, y, ring || core);
+  }
+  for (let i = 0; i < 8; i++) { matrix.unset(7, i); matrix.unset(i, 7); }
+  for (let i = 8; i < size; i++) if ((i & 1) === 0) { matrix.set(i, 0); matrix.set(0, i); }
+}
+
+function microMaskScore(matrix) {
+  let right = 0, bottom = 0;
+  for (let i = 1; i < matrix.width; i++) {
+    if (matrix.get(matrix.width - 1, i)) right++;
+    if (matrix.get(i, matrix.height - 1)) bottom++;
+  }
+  return Math.min(right, bottom) * 16 + Math.max(right, bottom);
+}
+
+function buildMatrix(version, ecc, mask, bits) {
+  const matrix = new BitMatrix(microQrVersionSize(version));
+  drawFunctions(matrix);
+  const order = microQrDataModuleOrder(version);
+  for (let i = 0; i < bits.length; i++) {
+    const x = order[i * 2], y = order[i * 2 + 1];
+    matrix.setValue(x, y, (bits[i] === 1) !== microQrMaskBit(mask, x, y));
+  }
+  const format = microQrFormatInfo(microQrSymbolNumber(version, ecc), mask);
+  const positions = microQrFormatInfoPositions(matrix.width);
+  for (let i = 0; i < 15; i++) matrix.setValue(positions[i][0], positions[i][1], ((format >>> i) & 1) === 1);
+  return matrix;
+}
+function encodeMicroQR(text, options = {}) {
+  text = String(text);
+  if (!text) throw new EncodeError('Micro QR: payload must not be empty');
+  if (options.eci != null || options.gs1 === true) throw new EncodeError('Micro QR: ECI and GS1/FNC1 are unavailable');
+  const mode = chooseMode(text, options.mode);
+  const wantedVersion = parseVersion(options.version);
+  const wantedEcc = options.ecc == null ? null : String(options.ecc).toUpperCase();
+  if (wantedEcc === 'H') throw new EncodeError('Micro QR: error correction level H is unavailable');
+  if (options.mask != null && (!Number.isInteger(options.mask) || options.mask < 0 || options.mask > 3)) {
+    throw new EncodeError(`Micro QR: mask must be an integer 0-3, got ${options.mask}`);
+  }
+
+  let selected;
+  for (const version of MICROQR_VERSIONS) {
+    if (wantedVersion != null && version !== wantedVersion) continue;
+    const numericVersion = versionNumber(version);
+    if (numericVersion < MODE_MIN_VERSION[mode]) continue;
+    const levels = numericVersion === 1 ? ['DETECT'] : numericVersion < 4 ? ['L', 'M'] : ['L', 'M', 'Q'];
+    for (const ecc of levels) {
+      if (wantedEcc != null && ecc !== wantedEcc) continue;
+      const layout = microQrBlockLayout(version, ecc);
+      const data = writeData(text, mode, version, layout);
+      if (data) { selected = { version, ecc, layout, data }; break; }
+    }
+    if (selected) break;
+  }
+  if (!selected) throw new EncodeError('Micro QR: payload does not fit the requested version/error level');
+  const bits = finalMessage(selected.data, selected.layout);
+  if (options.mask != null) return buildMatrix(selected.version, selected.ecc, options.mask, bits);
+  let best, score = -1;
+  for (let mask = 0; mask < 4; mask++) {
+    const candidate = buildMatrix(selected.version, selected.ecc, mask, bits);
+    const candidateScore = microMaskScore(candidate);
+    if (candidateScore > score) { score = candidateScore; best = candidate; }
+  }
+  return best;
+}
+
+__exports.MICROQR_ALPHANUMERIC = MICROQR_ALPHANUMERIC;
+__exports.encodeMicroQR = encodeMicroQR;
+};
+
+__modules["microqr/decoder.js"] = function (__require, __exports) {
+/**
+ * Micro QR decoder for an already sampled M1-M4 module matrix.
+ *
+ * @module microqr/decoder
+ */
+const { ChecksumError, FormatError } = __require("core/errors.js");
+const { GF256_QR } = __require("core/galois-field.js");
+const { rsDecode } = __require("core/reed-solomon.js");
+const { microQrBlockLayout, microQrDataModuleOrder, microQrDecodeFormatInfo, microQrFormatInfoPositions, microQrMaskBit } = __require("microqr/tables.js");
+
+const ALPHANUMERIC = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+const MODE_NAMES = ['numeric', 'alphanumeric', 'byte', 'kanji'];
+const COUNT_BITS = {
+  numeric: [0, 3, 4, 5, 6],
+  alphanumeric: [0, 0, 3, 4, 5],
+  byte: [0, 0, 0, 4, 5],
+  kanji: [0, 0, 0, 3, 4],
+};
+
+class LimitedBitReader {
+  constructor(bytes, limit) {
+    this.bytes = bytes;
+    this.limit = limit;
+    this.offset = 0;
+  }
+
+  available() { return this.limit - this.offset; }
+
+  read(count) {
+    if (!Number.isInteger(count) || count < 1 || count > 32 || count > this.available()) {
+      throw new FormatError(`Micro QR: needed ${count} bits, ${Math.max(0, this.available())} remain`);
+    }
+    let value = 0;
+    for (let i = 0; i < count; i++, this.offset++) {
+      value = (value << 1) | ((this.bytes[this.offset >>> 3] >>> (7 - (this.offset & 7))) & 1);
+    }
+    return value >>> 0;
+  }
+}
+
+function moduleAt(matrix, x, y, mirrored) {
+  return mirrored ? matrix.get(y, x) : matrix.get(x, y);
+}
+
+function readFormat(matrix, expectedVersion, mirrored) {
+  let bits = 0;
+  const positions = microQrFormatInfoPositions(matrix.width);
+  for (let i = 0; i < positions.length; i++) {
+    const [x, y] = positions[i];
+    if (moduleAt(matrix, x, y, mirrored)) bits |= 1 << i;
+  }
+  const format = microQrDecodeFormatInfo(bits);
+  if (!format) throw new FormatError('Micro QR: format information is unreadable');
+  if (format.version !== expectedVersion) {
+    throw new FormatError(
+      `Micro QR: format identifies ${format.version}, but the matrix dimension identifies ${expectedVersion}`,
+    );
+  }
+  return format;
+}
+
+function readCodewords(matrix, layout, mask, mirrored) {
+  const order = microQrDataModuleOrder(layout.version);
+  const data = new Array(layout.dataCodewords).fill(0);
+  const ecc = new Array(layout.eccCodewords).fill(0);
+  let streamOffset = 0;
+
+  const readBit = () => {
+    const x = order[streamOffset * 2];
+    const y = order[streamOffset * 2 + 1];
+    if (x === undefined || y === undefined) throw new FormatError('Micro QR: encoding region is truncated');
+    streamOffset++;
+    return moduleAt(matrix, x, y, mirrored) !== microQrMaskBit(mask, x, y) ? 1 : 0;
+  };
+  const readInto = (target, index, count, highBit = 7) => {
+    for (let bit = highBit; bit > highBit - count; bit--) target[index] |= readBit() << bit;
+  };
+
+  const fullData = layout.shortDataCodewordBits === 4 ? layout.dataCodewords - 1 : layout.dataCodewords;
+  for (let i = 0; i < fullData; i++) readInto(data, i, 8);
+  if (layout.shortDataCodewordBits === 4) readInto(data, data.length - 1, 4);
+  for (let i = 0; i < ecc.length; i++) readInto(ecc, i, 8);
+
+  if (streamOffset !== order.length / 2) {
+    throw new FormatError(`Micro QR: read ${streamOffset} of ${order.length / 2} encoding modules`);
+  }
+  return data.concat(ecc);
+}
+
+function correctCodewords(received, layout) {
+  const corrections = rsDecode(received, layout.eccCodewords, GF256_QR, 0);
+  if (layout.version === 'M1' && corrections !== 0) {
+    throw new ChecksumError('Micro QR: M1 provides error detection only');
+  }
+  return { data: Uint8Array.from(received.slice(0, layout.dataCodewords)), corrections };
+}
+
+function decodeKanjiValue(value) {
+  const combined = (Math.floor(value / 0xc0) << 8) | (value % 0xc0);
+  const sjis = combined + (combined < 0x1f00 ? 0x8140 : 0xc140);
+  const bytes = Uint8Array.of(sjis >>> 8, sjis & 0xff);
+  try {
+    return new TextDecoder('shift_jis', { fatal: true }).decode(bytes);
+  } catch {
+    throw new FormatError(`Micro QR: invalid Kanji value ${value}`);
+  }
+}
+
+function parsePayload(data, version, dataBits) {
+  const reader = new LimitedBitReader(data, dataBits);
+  const modeValue = version === 1 ? 0 : reader.read(version - 1);
+  if (modeValue > 3 || (version === 2 && modeValue > 1)) {
+    throw new FormatError(`Micro QR: mode indicator ${modeValue} is unavailable in M${version}`);
+  }
+  const mode = MODE_NAMES[modeValue];
+  const countWidth = COUNT_BITS[mode][version];
+  if (!countWidth) throw new FormatError(`Micro QR: ${mode} mode is unavailable in M${version}`);
+  const count = reader.read(countWidth);
+  if (count === 0) throw new FormatError('Micro QR: zero-length data segment');
+
+  let text = '';
+  const rawBytes = [];
+  if (mode === 'numeric') {
+    let remaining = count;
+    while (remaining >= 3) {
+      const value = reader.read(10);
+      if (value >= 1000) throw new FormatError(`Micro QR: invalid numeric triplet ${value}`);
+      text += String(value).padStart(3, '0');
+      remaining -= 3;
+    }
+    if (remaining === 2) {
+      const value = reader.read(7);
+      if (value >= 100) throw new FormatError(`Micro QR: invalid numeric pair ${value}`);
+      text += String(value).padStart(2, '0');
+    } else if (remaining === 1) {
+      const value = reader.read(4);
+      if (value >= 10) throw new FormatError(`Micro QR: invalid numeric digit ${value}`);
+      text += String(value);
+    }
+  } else if (mode === 'alphanumeric') {
+    let remaining = count;
+    while (remaining >= 2) {
+      const value = reader.read(11);
+      if (value >= 45 * 45) throw new FormatError(`Micro QR: invalid alphanumeric pair ${value}`);
+      text += ALPHANUMERIC[Math.floor(value / 45)] + ALPHANUMERIC[value % 45];
+      remaining -= 2;
+    }
+    if (remaining === 1) {
+      const value = reader.read(6);
+      if (value >= 45) throw new FormatError(`Micro QR: invalid alphanumeric value ${value}`);
+      text += ALPHANUMERIC[value];
+    }
+  } else if (mode === 'byte') {
+    for (let i = 0; i < count; i++) {
+      const value = reader.read(8);
+      rawBytes.push(value);
+      text += String.fromCharCode(value);
+    }
+  } else {
+    for (let i = 0; i < count; i++) text += decodeKanjiValue(reader.read(13));
+  }
+  return { text, bytes: Uint8Array.from(rawBytes), mode };
+}
+
+function decodeOrientation(matrix, expectedVersion, mirrored) {
+  const format = readFormat(matrix, expectedVersion, mirrored);
+  const layout = microQrBlockLayout(format.version, format.ecc);
+  const received = readCodewords(matrix, layout, format.mask, mirrored);
+  const { data, corrections } = correctCodewords(received, layout);
+  const payload = parsePayload(data, Number(format.version.slice(1)), layout.dataBits);
+  return {
+    text: payload.text,
+    bytes: payload.bytes,
+    mode: payload.mode,
+    version: format.version,
+    ecc: format.ecc,
+    mask: format.mask,
+    corrections,
+    formatCorrections: format.correctedBits,
+    mirrored,
+  };
+}
+
+/** Decode a sampled Micro QR Code symbol without its quiet zone. */
+function decodeMicroQR(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || typeof matrix.get !== 'function') {
+    throw new FormatError('Micro QR: no matrix supplied');
+  }
+  if (matrix.height !== matrix.width) {
+    throw new FormatError(`Micro QR: symbol must be square, got ${matrix.width}x${matrix.height}`);
+  }
+  const version = (matrix.width - 9) / 2;
+  if (!Number.isInteger(version) || version < 1 || version > 4) {
+    throw new FormatError(`Micro QR: ${matrix.width} modules is not a valid M1-M4 symbol size`);
+  }
+  const expectedVersion = `M${version}`;
+  try {
+    return decodeOrientation(matrix, expectedVersion, false);
+  } catch (primaryError) {
+    try {
+      return decodeOrientation(matrix, expectedVersion, true);
+    } catch {
+      throw primaryError;
+    }
+  }
+}
+__exports.ChecksumError = ChecksumError; __exports.FormatError = FormatError;
+
+__exports.decodeMicroQR = decodeMicroQR;
+};
+
+__modules["microqr/detector.js"] = function (__require, __exports) {
+/**
+ * Micro QR detection in binarized rasters.
+ *
+ * A Micro QR symbol has one 7x7 finder in its top-left corner. That alone is
+ * not enough to distinguish it from one corner of a normal QR Code, so every
+ * candidate is also required to have the Micro QR timing arms and a format
+ * word which the decoder accepts. The decoder is deliberately the final
+ * geometric arbiter; BCH and Reed--Solomon verification make accidental
+ * acceptance of ordinary square artwork very unlikely.
+ *
+ * Finder geometry supplies two local axes. Timing arms refine their lengths,
+ * while a small fourth-corner search lets projective sampling absorb mild
+ * perspective despite the format having no remote alignment pattern.
+ *
+ * @module microqr/detector
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { NotFoundError } = __require("core/errors.js");
+const { sampleQuad } = __require("image/grid-sampler.js");
+const { decodeMicroQR } = __require("microqr/decoder.js");
+
+/** Legal Micro QR side lengths (M1 through M4). */
+const DIMENSIONS = [11, 13, 15, 17];
+
+/** @typedef {{x:number, y:number}} Point */
+
+/**
+ * @typedef {object} Detection
+ * @property {Point[]} corners Outer corners in reading order.
+ * @property {number} dimension Side length in modules.
+ * @property {'M1'|'M2'|'M3'|'M4'} version
+ * @property {number} moduleSize Estimated pixels per module at the finder.
+ * @property {number} rotation Clockwise orientation of the source raster.
+ * @property {boolean} inverted Whether the detected symbol used inverted polarity.
+ * @property {BitMatrix} matrix Rectified, normally polarised module matrix.
+ */
+
+function rotateVector(vector) {
+  return { x: -vector.y, y: vector.x };
+}
+
+function add(point, a, av, b, bv) {
+  return { x: point.x + a.x * av + b.x * bv, y: point.y + a.y * av + b.y * bv };
+}
+
+function sample(image, point) {
+  const x = Math.round(point.x);
+  const y = Math.round(point.y);
+  if (x < 0 || y < 0 || x >= image.width || y >= image.height) return null;
+  return image.get(x, y);
+}
+
+function expectedFinder(x, y) {
+  return x === 0 || y === 0 || x === 6 || y === 6 ||
+    (x >= 2 && x <= 4 && y >= 2 && y <= 4);
+}
+
+/** Connected components matching one polarity, capped to plausible centre blocks. */
+function components(image, value) {
+  const seen = new Uint8Array(image.width * image.height);
+  const result = [];
+  const maximumArea = Math.max(16, Math.floor(image.width * image.height * 0.08));
+
+  for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) {
+    const start = y * image.width + x;
+    if (seen[start] || image.get(x, y) !== value) continue;
+
+    const queueX = [x];
+    const queueY = [y];
+    seen[start] = 1;
+    let head = 0;
+    let minX = x; let maxX = x; let minY = y; let maxY = y;
+
+    while (head < queueX.length) {
+      const px = queueX[head];
+      const py = queueY[head++];
+      if (px < minX) minX = px;
+      if (px > maxX) maxX = px;
+      if (py < minY) minY = py;
+      if (py > maxY) maxY = py;
+      for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+        if (nx < 0 || ny < 0 || nx >= image.width || ny >= image.height) continue;
+        const index = ny * image.width + nx;
+        if (!seen[index] && image.get(nx, ny) === value) {
+          seen[index] = 1;
+          queueX.push(nx);
+          queueY.push(ny);
+        }
+      }
+    }
+
+    const width = maxX - minX + 1;
+    const height = maxY - minY + 1;
+    const area = width * height;
+    if (queueX.length > maximumArea || Math.min(width, height) < 2) continue;
+    if (Math.max(width, height) > Math.min(width, height) * 1.7) continue;
+    if (queueX.length < area * 0.42) continue;
+    result.push({
+      x: (minX + maxX) / 2,
+      y: (minY + maxY) / 2,
+      width,
+      height,
+      pixels: queueX.length,
+    });
+  }
+
+  return result.sort((a, b) => b.pixels - a.pixels).slice(0, 256);
+}
+
+/** Score the complete 7x7 finder at module centres. */
+function finderScore(image, centre, u, v, pitch, inverted) {
+  let correct = 0;
+  let total = 0;
+  for (let y = 0; y < 7; y++) for (let x = 0; x < 7; x++) {
+    const actual = sample(image, add(centre, u, (x - 3) * pitch, v, (y - 3) * pitch));
+    if (actual === null) continue;
+    const wanted = inverted ? !expectedFinder(x, y) : expectedFinder(x, y);
+    if (actual === wanted) correct++;
+    total++;
+  }
+  return total === 49 ? correct / total : 0;
+}
+
+/** Validate separator, timing arms and a sparse quiet-zone outline. */
+function structureScore(image, centre, u, v, pitch, dimension, sx, sy, inverted) {
+  let correct = 0;
+  let total = 0;
+  const check = (x, y, dark) => {
+    const point = add(centre, u, (x - 3) * pitch * sx, v, (y - 3) * pitch * sy);
+    const actual = sample(image, point);
+    if (actual !== null && actual === (inverted ? !dark : dark)) correct++;
+    total++;
+  };
+
+  // The light separator lies between the finder and encoding region.
+  for (let i = 0; i <= 7; i++) {
+    check(7, i, false);
+    check(i, 7, false);
+  }
+  // Both timing arms start dark at coordinate 8 and alternate to the edge.
+  for (let i = 8; i < dimension; i++) {
+    check(i, 0, (i & 1) === 0);
+    check(0, i, (i & 1) === 0);
+  }
+  // A quiet-zone sample just beyond each edge rejects an isolated normal-QR
+  // finder and most decorative squares without requiring a perfect crop.
+  for (let i = 0; i < dimension; i += 2) {
+    check(i, -1.25, false);
+    check(-1.25, i, false);
+    check(i, dimension + 0.75, false);
+    check(dimension + 0.75, i, false);
+  }
+  return correct / total;
+}
+
+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;
+}
+
+function orientationDegrees(u) {
+  const degrees = Math.atan2(u.y, u.x) * 180 / Math.PI;
+  return ((Math.round(degrees / 90) * 90) % 360 + 360) % 360;
+}
+
+function cornersFor(centre, u, v, pitch, dimension, sx, sy, dx = 0, dy = 0) {
+  const tl = add(centre, u, -3.5 * pitch, v, -3.5 * pitch);
+  const tr = add(tl, u, dimension * pitch * sx, v, 0);
+  const bl = add(tl, u, 0, v, dimension * pitch * sy);
+  const br = add(add(tr, v, dimension * pitch * sy, u, 0), u, dx * pitch, v, dy * pitch);
+  return [tl, tr, br, bl];
+}
+
+function candidateKey(detection) {
+  const centre = detection.finderCentre;
+  return `${Math.round(centre.x)},${Math.round(centre.y)},${detection.dimension}`;
+}
+
+function sameCandidate(left, right) {
+  if (left.dimension !== right.dimension) return false;
+  const centre = (detection) => detection.corners.reduce(
+    (sum, point) => ({ x: sum.x + point.x / 4, y: sum.y + point.y / 4 }),
+    { x: 0, y: 0 },
+  );
+  const a = centre(left);
+  const b = centre(right);
+  const tolerance = Math.max(left.moduleSize, right.moduleSize) * 2;
+  return Math.hypot(a.x - b.x, a.y - b.y) < tolerance;
+}
+
+/**
+ * Find Micro QR symbols in a binarized raster.
+ *
+ * The search accepts arbitrary in-plane angles, including all quarter-turns.
+ * Non-integer scale is supported through centre sampling. Mild projective
+ * distortion is handled by searching the unconstrained fourth corner.
+ *
+ * @param {BitMatrix} binaryImage Set bit = dark.
+ * @returns {Detection[]} Best candidate first; empty when no symbol is found.
+ */
+function detectMicroQR(binaryImage) {
+  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+    throw new NotFoundError('detectMicroQR: no image supplied');
+  }
+
+  const detections = [];
+  const seen = new Set();
+
+  for (const inverted of [false, true]) {
+    for (const centre of components(binaryImage, !inverted)) {
+      for (let degrees = 0; degrees < 180; degrees += 3) {
+        const angle = degrees * Math.PI / 180;
+        const axis = { x: Math.cos(angle), y: Math.sin(angle) };
+        const perpendicular = rotateVector(axis);
+        const footprint = Math.abs(axis.x) + Math.abs(axis.y);
+        const pitch = ((centre.width + centre.height) / 2) / (3 * footprint);
+        if (pitch < 0.75) continue;
+
+        // The finder is rotationally symmetric; four turns decide which pair
+        // of arms points into the encoding region.
+        for (let turn = 0, u = axis, v = perpendicular; turn < 4; turn++) {
+          if (turn > 0) { u = v; v = { x: -u.y, y: u.x }; }
+          const fScore = finderScore(binaryImage, centre, u, v, pitch, inverted);
+          if (fScore < 0.9) continue;
+
+          for (const dimension of DIMENSIONS) {
+            const scales = [0.84, 0.92, 1, 1.08, 1.16];
+            const rankedX = scales.map((scale) => ({
+              scale,
+              score: structureScore(binaryImage, centre, u, v, pitch, dimension, scale, 1, inverted),
+            })).sort((a, b) => b.score - a.score).slice(0, 2);
+            const rankedY = scales.map((scale) => ({
+              scale,
+              score: structureScore(binaryImage, centre, u, v, pitch, dimension, 1, scale, inverted),
+            })).sort((a, b) => b.score - a.score).slice(0, 2);
+
+            for (const xs of rankedX) for (const ys of rankedY) {
+              const score = structureScore(binaryImage, centre, u, v, pitch, dimension, xs.scale, ys.scale, inverted);
+              if (score < 0.78) continue;
+
+              // With a single finder there is no direct bottom-right anchor.
+              // A compact search around the affine estimate lets the projective
+              // sampler account for convergence of the remote edges.
+              for (const delta of [[0, 0], [-0.75, 0], [0.75, 0], [0, -0.75], [0, 0.75],
+                [-0.75, -0.75], [0.75, -0.75], [-0.75, 0.75], [0.75, 0.75]]) {
+                const corners = cornersFor(
+                  centre, u, v, pitch, dimension, xs.scale, ys.scale, delta[0], delta[1]
+                );
+                let matrix;
+                try { matrix = sampleQuad(binaryImage, dimension, corners, score < 0.9); }
+                catch (error) { continue; }
+                if (inverted) matrix = invert(matrix);
+
+                try {
+                  const decoded = decodeMicroQR(matrix);
+                  const version = decoded.version ?? `M${(dimension - 9) / 2}`;
+                  const detection = {
+                    corners,
+                    dimension,
+                    version,
+                    moduleSize: pitch,
+                    rotation: orientationDegrees(u),
+                    inverted,
+                    matrix,
+                    finderCentre: { x: centre.x, y: centre.y },
+                    score: fScore + score,
+                  };
+                  const key = candidateKey(detection);
+                  if (!seen.has(key) && !detections.some((entry) => sameCandidate(entry, detection))) {
+                    seen.add(key);
+                    detections.push(detection);
+                  }
+                  // Decoder validation settled this dimension and orientation.
+                  break;
+                } catch (error) {
+                  /* Try the next perspective hypothesis. */
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  detections.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
+  for (const detection of detections) {
+    delete detection.finderCentre;
+    delete detection.score;
+  }
+  return detections;
+}
+
+/**
+ * Detect and decode all Micro QR symbols in a binarized raster.
+ *
+ * @param {BitMatrix} binaryImage
+ * @returns {Array<object>}
+ */
+function detectAndDecodeMicroQR(binaryImage) {
+  let detections;
+  try { detections = detectMicroQR(binaryImage); }
+  catch (error) { return []; }
+
+  const results = [];
+  const seen = new Set();
+  for (const detection of detections) {
+    try {
+      const decoded = decodeMicroQR(detection.matrix);
+      const key = `${decoded.version ?? detection.version}|${decoded.text ?? ''}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(Object.assign({
+        corners: detection.corners,
+        rotation: detection.rotation,
+        inverted: detection.inverted,
+      }, decoded));
+    } catch (error) {
+      /* A failed candidate is a normal no-symbol result. */
+    }
+  }
+  return results;
+}
+
+__exports.detectMicroQR = detectMicroQR;
+__exports.detectAndDecodeMicroQR = detectAndDecodeMicroQR;
+};
+
+__modules["microqr/index.js"] = function (__require, __exports) {
+/** Micro QR Code M1-M4 public module surface. @module microqr */
+const __reexport0 = __require("microqr/encoder.js"); __exports.encodeMicroQR = __reexport0.encodeMicroQR;
+const __reexport1 = __require("microqr/decoder.js"); __exports.decodeMicroQR = __reexport1.decodeMicroQR;
+const __reexport2 = __require("microqr/detector.js"); __exports.detectMicroQR = __reexport2.detectMicroQR; __exports.detectAndDecodeMicroQR = __reexport2.detectAndDecodeMicroQR;
+const __reexport3 = __require("microqr/tables.js"); __exports.validateMicroQrTables = __reexport3.validateMicroQrTables;
+
+
+};
+
+__modules["rmqr/tables.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+
+/** The 32 rMQR dimensions in ISO/IEC 23941 order (width, height). */
+const RMQR_SIZES = Object.freeze([
+  [43, 7], [59, 7], [77, 7], [99, 7], [139, 7],
+  [43, 9], [59, 9], [77, 9], [99, 9], [139, 9],
+  [27, 11], [43, 11], [59, 11], [77, 11], [99, 11], [139, 11],
+  [27, 13], [43, 13], [59, 13], [77, 13], [99, 13], [139, 13],
+  [43, 15], [59, 15], [77, 15], [99, 15], [139, 15],
+  [43, 17], [59, 17], [77, 17], [99, 17], [139, 17],
+]);
+
+const REMAINDER_BITS = Object.freeze([0, 3, 5, 6, 1, 2, 3, 1, 4, 5, 2, 1, 0, 2, 7, 6, 4, 1, 6, 4, 3, 0, 1, 4, 6, 7, 2, 1, 2, 0, 3, 4]);
+const TOTAL_CODEWORDS = Object.freeze([13, 21, 32, 44, 68, 21, 33, 49, 66, 99, 15, 31, 47, 67, 89, 132, 21, 41, 60, 85, 113, 166, 51, 74, 103, 136, 199, 61, 88, 122, 160, 232]);
+
+// Each block is [number of blocks, total codewords per block, data codewords per block].
+const M_BLOCKS = [
+  [[1, 13, 6]], [[1, 21, 12]], [[1, 32, 20]], [[1, 44, 28]], [[1, 68, 44]],
+  [[1, 21, 12]], [[1, 33, 21]], [[1, 49, 31]], [[1, 66, 42]], [[1, 49, 31], [1, 50, 32]],
+  [[1, 15, 7]], [[1, 31, 19]], [[1, 47, 31]], [[1, 67, 43]], [[1, 44, 28], [1, 45, 29]], [[2, 66, 42]],
+  [[1, 21, 14]], [[1, 41, 27]], [[1, 60, 38]], [[1, 42, 26], [1, 43, 27]], [[1, 56, 36], [1, 57, 37]], [[2, 55, 35], [1, 56, 36]],
+  [[1, 51, 33]], [[1, 74, 48]], [[1, 51, 33], [1, 52, 34]], [[2, 68, 44]], [[2, 66, 42], [1, 67, 43]],
+  [[1, 60, 39]], [[2, 44, 28]], [[2, 61, 39]], [[2, 53, 33], [1, 54, 34]], [[4, 58, 38]],
+];
+const H_BLOCKS = [
+  [[1, 13, 3]], [[1, 21, 7]], [[1, 32, 10]], [[1, 44, 14]], [[2, 34, 12]],
+  [[1, 21, 7]], [[1, 33, 11]], [[1, 24, 8], [1, 25, 9]], [[2, 33, 11]], [[3, 33, 11]],
+  [[1, 15, 5]], [[1, 31, 11]], [[1, 23, 7], [1, 24, 8]], [[1, 33, 11], [1, 34, 12]], [[1, 44, 14], [1, 45, 15]], [[3, 44, 14]],
+  [[1, 21, 7]], [[1, 41, 13]], [[2, 30, 10]], [[1, 42, 14], [1, 43, 15]], [[1, 37, 11], [2, 38, 12]], [[2, 41, 13], [2, 42, 14]],
+  [[1, 25, 7], [1, 26, 8]], [[2, 37, 13]], [[2, 34, 10], [1, 35, 11]], [[4, 34, 12]], [[1, 39, 13], [4, 40, 14]],
+  [[1, 30, 10], [1, 31, 11]], [[2, 44, 14]], [[1, 40, 12], [2, 41, 13]], [[4, 40, 14]], [[2, 38, 12], [4, 39, 13]],
+];
+
+const COUNT_BITS = Object.freeze({
+  numeric: [4, 5, 6, 7, 7, 5, 6, 7, 7, 8, 4, 6, 7, 7, 8, 8, 5, 6, 7, 7, 8, 8, 7, 7, 8, 8, 9, 7, 8, 8, 8, 9],
+  alphanumeric: [3, 5, 5, 6, 6, 5, 5, 6, 6, 7, 4, 5, 6, 6, 7, 7, 5, 6, 6, 7, 7, 8, 6, 7, 7, 7, 8, 6, 7, 7, 8, 8],
+  byte: [3, 4, 5, 5, 6, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 4, 6, 6, 7, 7, 7, 6, 6, 7, 7, 7, 6, 6, 7, 7, 8],
+  kanji: [2, 3, 4, 5, 5, 3, 4, 5, 5, 6, 2, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 5, 5, 6, 6, 7, 5, 6, 6, 6, 7],
+});
+
+const ALIGNMENT_BY_WIDTH = Object.freeze({ 27: [], 43: [21], 59: [19, 39], 77: [25, 51], 99: [23, 49, 75], 139: [27, 55, 83, 111] });
+
+/** @param {number} version */
+function versionInfo(version) {
+  if (!Number.isInteger(version) || version < 1 || version > 32) throw new RangeError(`rMQR: version must be 1-32, got ${version}`);
+  const [width, height] = RMQR_SIZES[version - 1];
+  const blockTable = (ecc) => ecc === 'M' ? M_BLOCKS[version - 1] : H_BLOCKS[version - 1];
+  const blockLayout = (ecc) => {
+    if (ecc !== 'M' && ecc !== 'H') throw new RangeError(`rMQR: ECC must be M or H, got ${ecc}`);
+    const blocks = [];
+    for (const [count, total, data] of blockTable(ecc)) for (let i = 0; i < count; i++) blocks.push({ total, data, ecc: total - data });
+    return { blocks, totalCodewords: TOTAL_CODEWORDS[version - 1], totalDataCodewords: blocks.reduce((n, b) => n + b.data, 0), eccCodewords: blocks.reduce((n, b) => n + b.ecc, 0) };
+  };
+  return Object.freeze({ version, width, height, name: `R${height}x${width}`, indicator: version - 1, remainderBits: REMAINDER_BITS[version - 1], totalCodewords: TOTAL_CODEWORDS[version - 1], countBits(mode) { return COUNT_BITS[mode]?.[version - 1] ?? 0; }, blockLayout });
+}
+
+/** @param {number} width @param {number} height */
+function versionForSize(width, height) {
+  const i = RMQR_SIZES.findIndex(([w, h]) => w === width && h === height);
+  return i < 0 ? null : versionInfo(i + 1);
+}
+
+/** @param {number} version */
+function alignmentCoordinates(version) { return ALIGNMENT_BY_WIDTH[versionInfo(version).width] || []; }
+
+function bchRemainder(value) {
+  const generator = 0x1f25;
+  let v = value << 12;
+  while (v !== 0 && v.toString(2).length >= 13) v ^= generator << (v.toString(2).length - 13);
+  return v;
+}
+
+/** Unmasked 18-bit format sequence: 5-bit version indicator plus ECC bit. */
+function formatBits(version, ecc) {
+  const v = versionInfo(version);
+  if (ecc !== 'M' && ecc !== 'H') throw new RangeError(`rMQR: ECC must be M or H, got ${ecc}`);
+  const data = v.indicator | (ecc === 'H' ? 1 << 5 : 0);
+  return (data << 12) | bchRemainder(data);
+}
+const FORMAT_MASK_FINDER = 0b011111101010110010;
+const FORMAT_MASK_SUB = 0b100000101001111011;
+
+/** rMQR has one fixed mask: floor(y/2)+floor(x/3) even. */
+function maskBit(x, y) { return (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0; }
+
+/** Function modules; set bits are non-data cells. */
+function functionModules(version) {
+  const v = versionInfo(version); const m = new BitMatrix(v.width, v.height); const { width: w, height: h } = v;
+  m.setRegion(0, 0, w, 1); m.setRegion(0, h - 1, w, 1); m.setRegion(0, 1, 1, h - 2); m.setRegion(w - 1, 1, 1, h - 2);
+  for (const cx of alignmentCoordinates(version)) { m.setRegion(cx - 1, 1, 3, 2); m.setRegion(cx - 1, h - 3, 3, 2); m.setRegion(cx, 3, 1, h - 6); }
+  m.setRegion(1, 1, 7, h === 7 ? 5 : 7); m.setRegion(8, 1, 3, 5); m.setRegion(11, 1, 1, 3);
+  m.setRegion(w - 5, h - 5, 4, 4); m.setRegion(w - 8, h - 6, 3, 5); m.setRegion(w - 5, h - 6, 3, 1);
+  m.set(w - 2, 1); if (h > 9) m.set(1, h - 2);
+  return m;
+}
+
+/** Data coordinates in the standard right-to-left two-column traversal. */
+function dataModuleOrder(version) {
+  const v = versionInfo(version); const fn = functionModules(version); const out = [];
+  let cx = v.width - 2, cy = v.height - 6, dy = -1;
+  // The data path starts beside the lower-right format area, then snakes
+  // through each pair of columns between the one-module outer border.
+  while (cx > 0) {
+    for (const xx of [cx, cx - 1]) if (!fn.get(xx, cy)) out.push([xx, cy]);
+    if (dy < 0 && cy === 1) { cx -= 2; dy = 1; }
+    else if (dy > 0 && cy === v.height - 2) { cx -= 2; dy = -1; }
+    else cy += dy;
+  }
+  return out;
+}
+function dataBitCapacity(version, ecc) { const b = versionInfo(version).blockLayout(ecc); return b.totalDataCodewords * 8; }
+function validateTables() {
+  const problems = [];
+  if (RMQR_SIZES.length !== 32) problems.push(`expected 32 sizes, got ${RMQR_SIZES.length}`);
+  for (let i = 1; i <= 32; i++) {
+    const v = versionInfo(i); const order = dataModuleOrder(i); const expected = v.totalCodewords * 8 + v.remainderBits;
+    if (order.length !== expected) problems.push(`${v.name}: data modules ${order.length}, expected ${expected}`);
+    for (const ecc of ['M', 'H']) { const b = v.blockLayout(ecc); if (b.totalCodewords !== v.totalCodewords) problems.push(`${v.name}-${ecc}: block total mismatch`); }
+  }
+  return problems;
+}
+
+__exports.RMQR_SIZES = RMQR_SIZES;
+__exports.versionInfo = versionInfo;
+__exports.versionForSize = versionForSize;
+__exports.alignmentCoordinates = alignmentCoordinates;
+__exports.formatBits = formatBits;
+__exports.FORMAT_MASK_FINDER = FORMAT_MASK_FINDER;
+__exports.FORMAT_MASK_SUB = FORMAT_MASK_SUB;
+__exports.maskBit = maskBit;
+__exports.functionModules = functionModules;
+__exports.dataModuleOrder = dataModuleOrder;
+__exports.dataBitCapacity = dataBitCapacity;
+__exports.validateTables = validateTables;
+};
+
+__modules["rmqr/encoder.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { BitWriter } = __require("core/bit-buffer.js");
+const { EncodeError } = __require("core/errors.js");
+const { GF256_QR } = __require("core/galois-field.js");
+const { rsEncode } = __require("core/reed-solomon.js");
+const { FORMAT_MASK_FINDER, FORMAT_MASK_SUB, dataBitCapacity, dataModuleOrder, formatBits, functionModules, maskBit, versionForSize, versionInfo } = __require("rmqr/tables.js");
+const ALPHANUMERIC_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+const MODE = Object.freeze({ TERMINATOR: 0, NUMERIC: 1, ALPHANUMERIC: 2, BYTE: 3, KANJI: 4, FNC1: 5, FNC1_SECOND: 6, ECI: 7 });
+
+function utf8Bytes(text) { return new TextEncoder().encode(text); }
+function latin1Bytes(text) { const out = new Uint8Array(text.length); for (let i = 0; i < text.length; i++) { const c = text.charCodeAt(i); if (c > 255) throw new EncodeError('rMQR: text is not ISO-8859-1'); out[i] = c; } return out; }
+function isAlpha(text) { for (const ch of text) if (ALPHANUMERIC_CHARS.indexOf(ch) < 0) return false; return true; }
+function isNumeric(text) { return /^[0-9]*$/.test(text); }
+
+let sjisMap;
+function getSjisMap() {
+  if (sjisMap !== undefined) return sjisMap;
+  try {
+    const decoder = new TextDecoder('shift_jis', { fatal: true });
+    if (decoder.decode(new Uint8Array([0x82, 0xa0])) !== 'あ') return (sjisMap = null);
+    const map = new Map(); const buf = new Uint8Array(2);
+    for (const [lo, hi] of [[0x8140, 0x9ffc], [0xe040, 0xebbf]]) for (let sjis = lo; sjis <= hi; sjis++) {
+      const trail = sjis & 255; if (trail < 0x40 || trail === 0x7f || trail > 0xfc) continue;
+      buf[0] = sjis >> 8; buf[1] = trail; let text; try { text = decoder.decode(buf); } catch { continue; }
+      if (Array.from(text).length === 1 && !map.has(text)) map.set(text, sjis);
+    }
+    return (sjisMap = map);
+  } catch { return (sjisMap = null); }
+}
+function kanjiValue(ch) {
+  const sjis = getSjisMap()?.get(ch); if (sjis === undefined) return -1;
+  let v; if (sjis >= 0x8140 && sjis <= 0x9ffc) v = sjis - 0x8140; else if (sjis >= 0xe040 && sjis <= 0xebbf) v = sjis - 0xc140; else return -1;
+  return ((v >> 8) * 0xc0) + (v & 0xff);
+}
+
+function chooseMode(text, requested) {
+  if (requested === 'numeric' || requested === 'alphanumeric' || requested === 'byte' || requested === 'kanji') return requested;
+  if (isNumeric(text)) return 'numeric';
+  if (isAlpha(text)) return 'alphanumeric';
+  return 'byte';
+}
+
+function modeBits(mode) { return MODE[mode.toUpperCase()] ?? MODE.BYTE; }
+function charCount(mode, text, bytes) { return mode === 'byte' ? bytes.length : mode === 'kanji' ? Array.from(text).length : text.length; }
+function payloadBits(mode, text, bytes) {
+  if (mode === 'numeric') { let n = 0; for (let i = 0; i < text.length; i += 3) n += text.length - i >= 3 ? 10 : text.length - i === 2 ? 7 : 4; return n; }
+  if (mode === 'alphanumeric') return Math.floor(text.length / 2) * 11 + (text.length & 1 ? 6 : 0);
+  if (mode === 'kanji') return Array.from(text).length * 13;
+  return bytes.length * 8;
+}
+
+function putEci(writer, assignment) {
+  writer.put(MODE.ECI, 3);
+  if (assignment <= 127) writer.put(assignment, 8);
+  else if (assignment <= 16383) writer.put(0x8000 | assignment, 16);
+  else if (assignment <= 999999) writer.put(0xc00000 | assignment, 24);
+  else throw new EncodeError(`rMQR: invalid ECI assignment ${assignment}`);
+}
+
+function makeData(text, v, ecc, options) {
+  const requested = options.mode;
+  const mode = chooseMode(text, requested);
+  const charset = options.charset || (mode === 'byte' && Array.from(text).every((ch) => ch.charCodeAt(0) <= 255) ? 'iso-8859-1' : 'utf-8');
+  const bytes = mode === 'byte' ? (charset === 'iso-8859-1' ? latin1Bytes(text) : utf8Bytes(text)) : new Uint8Array();
+  const countBits = v.countBits(mode);
+  if (!countBits) throw new EncodeError(`rMQR: unsupported mode ${mode}`);
+  const writer = new BitWriter();
+  if (options.eci !== undefined) putEci(writer, options.eci);
+  else if (mode === 'byte' && charset === 'utf-8') putEci(writer, 26);
+  writer.put(modeBits(mode), 3); writer.put(charCount(mode, text, bytes), countBits); // header
+  if (mode === 'numeric') for (let i = 0; i < text.length; i += 3) { const s = text.slice(i, i + 3); writer.put(Number(s), s.length === 3 ? 10 : s.length === 2 ? 7 : 4); }
+  else if (mode === 'alphanumeric') for (let i = 0; i < text.length; i += 2) { const a = ALPHANUMERIC_CHARS.indexOf(text[i]); const b = i + 1 < text.length ? ALPHANUMERIC_CHARS.indexOf(text[i + 1]) : -1; if (a < 0 || (b < 0 && i + 1 < text.length)) throw new EncodeError('rMQR: invalid alphanumeric character'); writer.put(b < 0 ? a : a * 45 + b, b < 0 ? 6 : 11); }
+  else if (mode === 'kanji') for (const ch of Array.from(text)) { const value = kanjiValue(ch); if (value < 0) throw new EncodeError(`rMQR: character ${ch} is not encodable in Kanji mode`); writer.put(value, 13); }
+  else writer.putBytes(bytes);
+  const capacity = dataBitCapacity(v.version, ecc);
+  if (writer.length > capacity) throw new EncodeError(`rMQR: payload does not fit ${v.name}-${ecc}`);
+  if (writer.length + 3 <= capacity) writer.put(0, 3);
+  while (writer.length & 7) writer.putBit(false);
+  const dataBytes = v.blockLayout(ecc).totalDataCodewords;
+  let pad = 0xec; while (writer.toBytes().length < dataBytes) { writer.put(pad, 8); pad = pad === 0xec ? 0x11 : 0xec; }
+  return writer.toBytes();
+}
+
+function interleave(data, v, ecc) {
+  const layout = v.blockLayout(ecc); const blocks = []; let offset = 0;
+  for (const b of layout.blocks) { const d = Array.from(data.slice(offset, offset + b.data)); offset += b.data; blocks.push({ data: d, ecc: rsEncode(d, b.ecc, GF256_QR, 0) }); }
+  const out = []; const maxData = Math.max(...blocks.map((b) => b.data.length)); const maxEcc = Math.max(...blocks.map((b) => b.ecc.length));
+  for (let i = 0; i < maxData; i++) for (const b of blocks) if (i < b.data.length) out.push(b.data[i]);
+  for (let i = 0; i < maxEcc; i++) for (const b of blocks) if (i < b.ecc.length) out.push(b.ecc[i]);
+  return Uint8Array.from(out);
+}
+
+function drawFunctions(m, version) {
+  const v = versionInfo(version); const fn = functionModules(version); const { width: w, height: h } = v;
+  const setIfData = (x, y, on) => { if (!fn.get(x, y)) m.setValue(x, y, on); };
+  for (let x = 0; x < w; x++) { m.setValue(x, 0, (x & 1) === 0); m.setValue(x, h - 1, (x & 1) === 0); }
+  for (const x of [0, w - 1, ...new Set([...(awaitableAlignment(version))])]) for (let y = 0; y < h; y++) setIfData(x, y, (y & 1) === 0);
+  for (const cx of awaitableAlignment(version)) for (const y of [0, 1, h - 2, h - 1]) m.setValue(cx + (y === 0 || y === h - 1 ? 0 : 0), y, false);
+  // Alignment patterns (top and bottom).
+  for (const cx of awaitableAlignment(version)) for (let i = 0; i < 3; i++) for (let j = 0; j < 3; j++) { const on = i === 0 || i === 2 || j === 0 || j === 2; m.setValue(cx + j - 1, i, on); m.setValue(cx + j - 1, h - 1 - i, on); }
+  // Finder and separator.
+  for (let i = 0; i < 7; i++) for (let j = 0; j < 7; j++) m.setValue(j, i, i === 0 || i === 6 || j === 0 || j === 6 || (i >= 2 && i <= 4 && j >= 2 && j <= 4));
+  for (let n = 0; n < 8; n++) { if (n < h) m.setValue(7, n, false); if (h >= 9) m.setValue(n, 7, false); }
+  for (let i = 0; i < 5; i++) for (let j = 0; j < 5; j++) m.setValue(w - j - 1, h - i - 1, i === 0 || i === 4 || j === 0 || j === 4 || (i === 2 && j === 2));
+  m.set(w - 1, 0); m.set(w - 2, 0); m.set(w - 1, 1); if (h >= 11) { m.set(0, h - 1); m.set(1, h - 1); m.set(2, h - 1); m.set(0, h - 2); }
+}
+
+// Kept as a local helper so drawFunctions stays independent of mutable tables.
+function awaitableAlignment(version) { return ({ 27: [], 43: [21], 59: [19, 39], 77: [25, 51], 99: [23, 49, 75], 139: [27, 55, 83, 111] })[versionInfo(version).width] || []; }
+
+function drawFormat(m, version, ecc) {
+  const v = versionInfo(version); let bits = formatBits(version, ecc) ^ FORMAT_MASK_FINDER;
+  for (let n = 0; n < 18; n++) m.setValue(8 + Math.floor(n / 5), 1 + (n % 5), ((bits >>> n) & 1) !== 0);
+  bits = formatBits(version, ecc) ^ FORMAT_MASK_SUB;
+  for (let n = 0; n < 15; n++) m.setValue(v.width - 8 + Math.floor(n / 5), v.height - 6 + (n % 5), ((bits >>> n) & 1) !== 0);
+  for (let n = 15; n < 18; n++) m.setValue(v.width - 5 + (n - 15), v.height - 6, ((bits >>> n) & 1) !== 0);
+}
+
+function buildMatrix(version, ecc, codewords) {
+  const v = versionInfo(version); const m = new BitMatrix(v.width, v.height); drawFunctions(m, version); drawFormat(m, version, ecc);
+  const fn = functionModules(version); const order = dataModuleOrder(version); let bit = 0; for (const [x, y] of order) { let on = bit < codewords.length * 8 && ((codewords[bit >>> 3] >>> (7 - (bit & 7))) & 1) !== 0; if (maskBit(x, y)) on = !on; m.setValue(x, y, on); bit++; }
+  return m;
+}
+
+/** Encode text into a rMQR module matrix. */
+function encodeRMQR(text, options = {}) {
+  if (typeof text !== 'string' || text.length === 0) throw new EncodeError('rMQR: text must be a non-empty string');
+  const ecc = options.ecc || 'M'; if (ecc !== 'M' && ecc !== 'H') throw new EncodeError('rMQR: ECC must be M or H');
+  let forced = options.version; if (typeof forced === 'string') { const match = /^R(\d+)x(\d+)$/i.exec(forced); if (!match) throw new EncodeError(`rMQR: invalid version ${forced}`); const info = versionForSize(Number(match[2]), Number(match[1])); if (!info) throw new EncodeError(`rMQR: unsupported version ${forced}`); forced = info.version; }
+  if (forced !== undefined && (!Number.isInteger(forced) || forced < 1 || forced > 32)) throw new EncodeError('rMQR: version must be 1-32');
+  const versions = forced ? [forced] : Array.from({ length: 32 }, (_, i) => i + 1);
+  let selected = null;
+  for (const n of versions) { const v = versionInfo(n); try { const data = makeData(text, v, ecc, options); selected = { v, data }; break; } catch (error) { if (forced) throw error; } }
+  if (!selected) throw new EncodeError(`rMQR: text is too long for ECC ${ecc}`);
+  const codewords = interleave(selected.data, selected.v, ecc); const matrix = buildMatrix(selected.v.version, ecc, codewords); matrix.rmqr = { version: selected.v.version, name: selected.v.name, ecc }; return matrix;
+}
+__exports.MODE = MODE;
+
+__exports.ALPHANUMERIC_CHARS = ALPHANUMERIC_CHARS;
+__exports.encodeRMQR = encodeRMQR;
+};
+
+__modules["rmqr/decoder.js"] = function (__require, __exports) {
+const { BitReader } = __require("core/bit-buffer.js");
+const { ChecksumError, FormatError } = __require("core/errors.js");
+const { GF256_QR } = __require("core/galois-field.js");
+const { rsDecode } = __require("core/reed-solomon.js");
+const { FORMAT_MASK_FINDER, FORMAT_MASK_SUB, dataModuleOrder, functionModules, maskBit, versionForSize, versionInfo, formatBits } = __require("rmqr/tables.js");
+const { ALPHANUMERIC_CHARS, MODE } = __require("rmqr/encoder.js");
+
+function hamming(a, b) { let v = a ^ b, n = 0; while (v) { v &= v - 1; n++; } return n; }
+function readFormat(matrix, v) {
+  let a = 0; for (let n = 0; n < 18; n++) if (matrix.get(8 + Math.floor(n / 5), 1 + (n % 5))) a |= 1 << n;
+  let b = 0; for (let n = 0; n < 15; n++) if (matrix.get(v.width - 8 + Math.floor(n / 5), v.height - 6 + (n % 5))) b |= 1 << n;
+  for (let n = 15; n < 18; n++) if (matrix.get(v.width - 5 + (n - 15), v.height - 6)) b |= 1 << n;
+  const candidates = [];
+  for (let version = 1; version <= 32; version++) for (const ecc of ['M', 'H']) {
+    candidates.push({ version, ecc, finder: formatBits(version, ecc) ^ FORMAT_MASK_FINDER, sub: formatBits(version, ecc) ^ FORMAT_MASK_SUB });
+  }
+  let best = null;
+  for (const c of candidates) for (const [value, expected] of [[a, c.finder], [b, c.sub]]) { const distance = hamming(value, expected); if (!best || distance < best.distance) best = { ...c, distance }; }
+  if (!best || best.distance > 3) throw new FormatError('rMQR: format information is unreadable');
+  return best;
+}
+
+function readCodewords(matrix, v, mask, total) {
+  const order = dataModuleOrder(v.version); const out = new Uint8Array(total); let bit = 0;
+  for (const [x, y] of order) { if (bit >= total * 8) break; let on = matrix.get(x, y); if (maskBit(x, y)) on = !on; if (on) out[bit >>> 3] |= 0x80 >>> (bit & 7); bit++; }
+  return out;
+}
+
+function deinterleave(codewords, v, ecc) {
+  const blocks = v.blockLayout(ecc).blocks; const arrays = blocks.map((b) => new Array(b.total).fill(0)); let offset = 0;
+  const maxData = Math.max(...blocks.map((b) => b.data)); for (let i = 0; i < maxData; i++) for (let b = 0; b < blocks.length; b++) if (i < blocks[b].data) arrays[b][i] = codewords[offset++];
+  const maxEcc = Math.max(...blocks.map((b) => b.ecc)); for (let i = 0; i < maxEcc; i++) for (let b = 0; b < blocks.length; b++) if (i < blocks[b].ecc) arrays[b][blocks[b].data + i] = codewords[offset++];
+  const data = []; let corrections = 0;
+  for (let b = 0; b < arrays.length; b++) { corrections += rsDecode(arrays[b], blocks[b].ecc, GF256_QR, 0); data.push(...arrays[b].slice(0, blocks[b].data)); }
+  return { data: Uint8Array.from(data), corrections };
+}
+
+function decodeBytes(bytes, eci) {
+  try { return new TextDecoder(eci === 26 ? 'utf-8' : 'iso-8859-1', { fatal: false }).decode(bytes); } catch { return String.fromCharCode(...bytes); }
+}
+function parseSegments(data, v) {
+  const reader = new BitReader(data); let text = ''; const raw = []; let eci = 3; let mode;
+  while (reader.available() >= 3) {
+    const peek = (() => { const save = { byteOffset: reader.byteOffset, bitOffset: reader.bitOffset }; const n = reader.read(3); reader.byteOffset = save.byteOffset; reader.bitOffset = save.bitOffset; return n; })();
+    if (peek === 0) break;
+    mode = reader.read(3);
+    if (mode === MODE.ECI) { const first = reader.read(8); let value; if (!(first & 0x80)) value = first; else if ((first & 0xc0) === 0x80) value = ((first & 0x3f) << 8) | reader.read(8); else if ((first & 0xe0) === 0xc0) value = ((first & 0x1f) << 16) | reader.read(16); else throw new FormatError('rMQR: invalid ECI'); eci = value; continue; }
+    const kind = mode === MODE.NUMERIC ? 'numeric' : mode === MODE.ALPHANUMERIC ? 'alphanumeric' : mode === MODE.BYTE ? 'byte' : mode === MODE.KANJI ? 'kanji' : null;
+    if (!kind) throw new FormatError(`rMQR: unsupported mode ${mode}`);
+    const count = reader.read(v.countBits(kind));
+    if (kind === 'numeric') { let remaining = count; while (remaining >= 3) { const n = reader.read(10).toString().padStart(3, '0'); text += n; remaining -= 3; } if (remaining === 2) text += reader.read(7).toString().padStart(2, '0'); else if (remaining === 1) text += reader.read(4).toString(); }
+    else if (kind === 'alphanumeric') { let remaining = count; while (remaining >= 2) { const n = reader.read(11); text += ALPHANUMERIC_CHARS[Math.floor(n / 45)] + ALPHANUMERIC_CHARS[n % 45]; remaining -= 2; } if (remaining) text += ALPHANUMERIC_CHARS[reader.read(6)]; }
+    else if (kind === 'byte') { const b = new Uint8Array(count); for (let i = 0; i < count; i++) { b[i] = reader.read(8); raw.push(b[i]); } text += decodeBytes(b, eci); }
+    else { const bytes = new Uint8Array(count * 2); for (let i = 0; i < count; i++) { const n = reader.read(13); const v2 = n; const high = Math.floor(v2 / 0xc0); const low = v2 % 0xc0; const sjis = high < 0x1f ? 0x8140 + (high << 8) + low : 0xc140 + (high << 8) + low; bytes[i * 2] = sjis >> 8; bytes[i * 2 + 1] = sjis & 255; } try { text += new TextDecoder('shift_jis').decode(bytes); } catch { text += String.fromCharCode(...bytes); } }
+  }
+  return { text, bytes: Uint8Array.from(raw) };
+}
+
+/** Decode an exact rMQR module matrix (without quiet zone). */
+function decodeRMQR(matrix) {
+  if (!matrix || !matrix.width || !matrix.height) throw new FormatError('rMQR: no matrix supplied');
+  const v = versionForSize(matrix.width, matrix.height); if (!v) throw new FormatError(`rMQR: unsupported symbol size ${matrix.width}x${matrix.height}`);
+  const info = readFormat(matrix, v); if (info.version !== v.version) throw new FormatError('rMQR: format/version mismatch');
+  const codewords = readCodewords(matrix, v, 4, v.totalCodewords); const corrected = deinterleave(codewords, v, info.ecc); const parsed = parseSegments(corrected.data, v);
+  return { ...parsed, version: v.version, name: v.name, ecc: info.ecc, mask: 4, corrections: corrected.corrections };
+}
+__exports.ChecksumError = ChecksumError;
+
+__exports.decodeRMQR = decodeRMQR;
+};
+
+__modules["rmqr/detector.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { NotFoundError } = __require("core/errors.js");
+const { decodeRMQR } = __require("rmqr/decoder.js");
+const { versionForSize } = __require("rmqr/tables.js");
+
+function rotate90(source) {
+  const out = new BitMatrix(source.height, source.width);
+  for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) if (source.get(x, y)) out.set(source.height - 1 - y, x);
+  return out;
+}
+function rotate180(source) { const out = new BitMatrix(source.width, source.height); for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) if (source.get(x, y)) out.set(source.width - 1 - x, source.height - 1 - y); return out; }
+function rotate270(source) { return rotate90(rotate180(source)); }
+function crop(source, box) {
+  const out = new BitMatrix(box.width, box.height); for (let y = 0; y < box.height; y++) for (let x = 0; x < box.width; x++) if (source.get(box.x + x, box.y + y)) out.set(x, y); return out;
+}
+function sample(matrix, width, height, scale, offsetX, offsetY) {
+  const out = new BitMatrix(width, height); const half = Math.max(0, Math.floor(scale / 2));
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    let dark = 0, count = 0; const x0 = offsetX + x * scale, y0 = offsetY + y * scale;
+    for (let yy = 0; yy < scale; yy++) for (let xx = 0; xx < scale; xx++) { if (matrix.get(x0 + xx, y0 + yy)) dark++; count++; }
+    if (dark * 2 >= count) out.set(x, y);
+  }
+  return out;
+}
+function bounds(matrix) { return matrix.getBounds(); }
+
+/** Detect an axis-aligned, clean rMQR raster and return the exact module matrix. */
+function detectRMQR(image, options = {}) {
+  if (!image || !image.width || !image.height) throw new NotFoundError('rMQR: no raster supplied');
+  if (options.perspective) throw new NotFoundError('rMQR: perspective detection is not available for clean-raster mode');
+  const orientations = [image, rotate90(image), rotate180(image), rotate270(image)];
+  for (let rotation = 0; rotation < orientations.length; rotation++) {
+    const source = orientations[rotation]; const box = bounds(source); if (!box) continue;
+    for (let version = 1; version <= 32; version++) {
+      const v = versionForSize(box.width, box.height); // exact modules, scale 1
+      if (v && v.version === version) {
+        try { const matrix = crop(source, box); const result = decodeRMQR(matrix); return { matrix, result, rotation, corners: { x: box.x, y: box.y, width: box.width, height: box.height } }; } catch { /* try next orientation/candidate */ }
+      }
+      // Integer nearest-neighbour scale. The dark bounding box must still be an
+      // exact multiple of the standard geometry; this rejects arbitrary text.
+      const candidate = versionForSize(box.width, box.height);
+      if (candidate) continue;
+      const canonical = (awaitableVersion(version));
+      const wScale = box.width / canonical.width;
+      const hScale = box.height / canonical.height;
+      if (!Number.isInteger(wScale) || wScale < 1 || wScale !== hScale) continue;
+      const info = canonical;
+      try { const matrix = sample(source, info.width, info.height, wScale, box.x, box.y); const result = decodeRMQR(matrix); return { matrix, result, rotation, scale: wScale, corners: { x: box.x, y: box.y, width: box.width, height: box.height } }; } catch { /* continue */ }
+    }
+  }
+  throw new NotFoundError('rMQR: no clean axis-aligned symbol found');
+}
+
+function awaitableVersion(version) {
+  const sizes = [[43, 7], [59, 7], [77, 7], [99, 7], [139, 7], [43, 9], [59, 9], [77, 9], [99, 9], [139, 9], [27, 11], [43, 11], [59, 11], [77, 11], [99, 11], [139, 11], [27, 13], [43, 13], [59, 13], [77, 13], [99, 13], [139, 13], [43, 15], [59, 15], [77, 15], [99, 15], [139, 15], [43, 17], [59, 17], [77, 17], [99, 17], [139, 17]];
+  return { version, width: sizes[version - 1][0], height: sizes[version - 1][1] };
+}
+
+/** Detect and decode a raster in one call. */
+function detectAndDecodeRMQR(image, options = {}) { return detectRMQR(image, options).result; }
+
+__exports.detectRMQR = detectRMQR;
+__exports.detectAndDecodeRMQR = detectAndDecodeRMQR;
+};
+
+__modules["rmqr/index.js"] = function (__require, __exports) {
+const __reexport0 = __require("rmqr/encoder.js"); __exports.encodeRMQR = __reexport0.encodeRMQR; __exports.ALPHANUMERIC_CHARS = __reexport0.ALPHANUMERIC_CHARS;
+const __reexport1 = __require("rmqr/decoder.js"); __exports.decodeRMQR = __reexport1.decodeRMQR;
+const __reexport2 = __require("rmqr/detector.js"); __exports.detectRMQR = __reexport2.detectRMQR; __exports.detectAndDecodeRMQR = __reexport2.detectAndDecodeRMQR;
+const __reexport3 = __require("rmqr/tables.js"); __exports.RMQR_SIZES = __reexport3.RMQR_SIZES; __exports.versionInfo = __reexport3.versionInfo; __exports.versionForSize = __reexport3.versionForSize; __exports.alignmentCoordinates = __reexport3.alignmentCoordinates; __exports.dataModuleOrder = __reexport3.dataModuleOrder; __exports.functionModules = __reexport3.functionModules; __exports.dataBitCapacity = __reexport3.dataBitCapacity; __exports.formatBits = __reexport3.formatBits; __exports.maskBit = __reexport3.maskBit; __exports.validateTables = __reexport3.validateTables;
+
+
+};
+
+__modules["frameqr/tables.js"] = function (__require, __exports) {
+/**
+ * Structural contract for the Sythos Canvas QR profile.
+ *
+ * DENSO WAVE's public material describes FrameQR(R) as a proprietary symbol
+ * with a freely shaped canvas, dedicated generation/reading software and no
+ * compatibility with ordinary QR readers. It does not publish the bitstream,
+ * placement or error-correction rules required for an interoperable encoder.
+ * Consequently this module does not claim to implement DENSO FrameQR.
+ *
+ * The implementable profile below starts with an ISO/IEC 18004 QR Model 2
+ * symbol at level H and clears a bounded group of data modules. Its worst-case
+ * damage is calculated per Reed-Solomon block and must remain within the
+ * standard QR correction radius. Function modules are never canvas modules.
+ * This provides a deterministic, independently testable canvas QR profile, but
+ * it is explicitly non-certified and not a substitute for proprietary FrameQR
+ * generation or validation software.
+ *
+ * @module frameqr/tables
+ */
+const { blockLayout, dataModuleOrder, reservedModules, versionSize } = __require("qr/tables.js");
+
+/** Public identity and compatibility boundary of the implementable profile. */
+const FRAMEQR_PROFILE = Object.freeze({
+  id: 'sythos-canvas-qr/1',
+  name: 'Sythos Canvas QR profile',
+  certified: false,
+  densoFrameQrCompatible: false,
+  baseSymbology: 'QR Code Model 2',
+  requiredEcc: 'H',
+  standard: 'ISO/IEC 18004 QR Code baseline',
+});
+
+/** Canvas shapes whose module membership is fully deterministic. */
+const FRAMEQR_CANVAS_SHAPES = Object.freeze(['square', 'circle', 'diamond']);
+
+function oddAtMost(value, maximum) {
+  let n = Math.max(1, Math.min(maximum, Math.floor(value)));
+  if ((n & 1) === 0) n--;
+  return Math.max(1, n);
+}
+
+function assertSymbolSize(symbolSize) {
+  if (!Number.isInteger(symbolSize) || symbolSize < 21 || symbolSize > 177 || (symbolSize - 17) % 4 !== 0) {
+    throw new RangeError(`Frame QR profile: ${symbolSize} is not a QR Model 2 symbol size`);
+  }
+}
+
+/**
+ * Canonicalise a canvas request.
+ *
+ * Coordinates and dimensions are module units. Odd dimensions make the centre
+ * unambiguous. Only quarter turns are accepted because arbitrary-angle raster
+ * membership would depend on renderer-specific sampling.
+ *
+ * @param {number} symbolSize QR module width/height (21..177).
+ * @param {object} [canvas]
+ * @returns {{shape:string,centerX:number,centerY:number,width:number,height:number,angle:number}}
+ */
+function normalizeCanvasSpec(symbolSize, canvas = {}) {
+  assertSymbolSize(symbolSize);
+  if (canvas === null || typeof canvas !== 'object' || Array.isArray(canvas)) {
+    throw new TypeError('Frame QR profile: canvas must be an object');
+  }
+
+  const shape = String(canvas.shape ?? 'square').toLowerCase();
+  if (!FRAMEQR_CANVAS_SHAPES.includes(shape)) {
+    throw new RangeError(`Frame QR profile: unsupported canvas shape "${shape}"`);
+  }
+
+  const defaultSize = oddAtMost(Math.max(3, Math.round(symbolSize * 0.17)), symbolSize - 16);
+  const requestedSize = canvas.size;
+  const requestedWidth = canvas.width ?? requestedSize ?? defaultSize;
+  const requestedHeight = canvas.height ?? requestedSize ?? defaultSize;
+  const maximumDimension = symbolSize - 16;
+  for (const [name, value] of [['width', requestedWidth], ['height', requestedHeight]]) {
+    if (!Number.isFinite(Number(value)) || Number(value) < 1 || Number(value) > maximumDimension) {
+      throw new RangeError(
+        `Frame QR profile: canvas ${name} must be between 1 and ${maximumDimension} modules`
+      );
+    }
+  }
+  const width = oddAtMost(Number(requestedWidth), maximumDimension);
+  const height = oddAtMost(Number(requestedHeight), maximumDimension);
+  const centerX = Math.round(canvas.centerX ?? (symbolSize - 1) / 2);
+  const centerY = Math.round(canvas.centerY ?? (symbolSize - 1) / 2);
+  const angle = ((Number(canvas.angle ?? 0) % 360) + 360) % 360;
+
+  if (![0, 90, 180, 270].includes(angle)) {
+    throw new RangeError('Frame QR profile: angle must be 0, 90, 180 or 270 degrees');
+  }
+  if (centerX < 8 || centerY < 8 || centerX >= symbolSize - 8 || centerY >= symbolSize - 8) {
+    throw new RangeError('Frame QR profile: canvas centre must remain inside the finder-pattern boundary');
+  }
+
+  return { shape, centerX, centerY, width, height, angle };
+}
+
+/**
+ * Enumerate canvas modules, including any overlaps with QR function modules.
+ * A conforming encoder rejects such overlaps rather than damaging function
+ * patterns.
+ *
+ * @param {number} symbolSize
+ * @param {object} [canvas]
+ * @returns {Array<[number, number]>}
+ */
+function canvasModules(symbolSize, canvas = {}) {
+  const spec = normalizeCanvasSpec(symbolSize, canvas);
+  const rotate = spec.angle === 90 || spec.angle === 270;
+  const width = rotate ? spec.height : spec.width;
+  const height = rotate ? spec.width : spec.height;
+  const halfWidth = (width - 1) / 2;
+  const halfHeight = (height - 1) / 2;
+  const modules = [];
+
+  for (let dy = -halfHeight; dy <= halfHeight; dy++) {
+    for (let dx = -halfWidth; dx <= halfWidth; dx++) {
+      const nx = halfWidth === 0 ? 0 : dx / halfWidth;
+      const ny = halfHeight === 0 ? 0 : dy / halfHeight;
+      let inside;
+      if (spec.shape === 'circle') inside = nx * nx + ny * ny <= 1 + Number.EPSILON;
+      else if (spec.shape === 'diamond') inside = Math.abs(nx) + Math.abs(ny) <= 1 + Number.EPSILON;
+      else inside = true;
+      if (inside) modules.push([spec.centerX + dx, spec.centerY + dy]);
+    }
+  }
+  return modules;
+}
+
+/** Build the interleaved-codeword to RS-block map used by QR Model 2. */
+function codewordBlockMap(layout) {
+  const dataCounts = new Array(layout.blockCount);
+  for (let block = 0; block < layout.blockCount; block++) {
+    dataCounts[block] = block < layout.group1Blocks
+      ? layout.group1DataCount
+      : layout.group2DataCount;
+  }
+
+  const map = [];
+  const maxData = Math.max(...dataCounts);
+  for (let i = 0; i < maxData; i++) {
+    for (let block = 0; block < layout.blockCount; block++) {
+      if (i < dataCounts[block]) map.push(block);
+    }
+  }
+  for (let i = 0; i < layout.eccPerBlock; i++) {
+    for (let block = 0; block < layout.blockCount; block++) map.push(block);
+  }
+  return map;
+}
+
+/**
+ * Calculate worst-case QR codeword damage caused by a canvas.
+ * A codeword is counted if any of its modules is touched. This is conservative:
+ * clearing an already-light module does no damage, but safety cannot depend on
+ * one payload or mask.
+ *
+ * @param {number} version QR version 1..40.
+ * @param {object} [canvas]
+ */
+function analyzeCanvasDamage(version, canvas = {}) {
+  if (!Number.isInteger(version) || version < 1 || version > 40) {
+    throw new RangeError(`Frame QR profile: version must be an integer 1-40, got ${version}`);
+  }
+  const symbolSize = versionSize(version);
+  const spec = normalizeCanvasSpec(symbolSize, canvas);
+  const modules = canvasModules(symbolSize, spec);
+  const reserved = reservedModules(version);
+  const reservedOverlaps = modules.filter(([x, y]) => reserved.get(x, y));
+
+  const moduleKeys = new Set(modules.map(([x, y]) => `${x},${y}`));
+  const order = dataModuleOrder(version);
+  const touchedCodewords = new Set();
+  for (let bit = 0; bit < order.length / 2; bit++) {
+    if (moduleKeys.has(`${order[bit * 2]},${order[bit * 2 + 1]}`)) touchedCodewords.add(bit >> 3);
+  }
+
+  const layout = blockLayout(version, 'H');
+  const blockMap = codewordBlockMap(layout);
+  const touchedByBlockSets = Array.from({ length: layout.blockCount }, () => new Set());
+  for (const codeword of touchedCodewords) {
+    const block = blockMap[codeword];
+    if (block !== undefined) touchedByBlockSets[block].add(codeword);
+  }
+  const touchedCodewordsByBlock = touchedByBlockSets.map((set) => set.size);
+  const correctionBudgetPerBlock = Math.floor(layout.eccPerBlock / 2);
+  const safe = reservedOverlaps.length === 0 &&
+    touchedCodewordsByBlock.every((count) => count <= correctionBudgetPerBlock);
+
+  return {
+    profile: FRAMEQR_PROFILE.id,
+    certified: false,
+    version,
+    symbolSize,
+    canvas: spec,
+    canvasModuleCount: modules.length,
+    reservedOverlaps,
+    touchedCodewordCount: touchedCodewords.size,
+    touchedCodewordsByBlock,
+    correctionBudgetPerBlock,
+    safe,
+  };
+}
+
+/** Validate a canvas and return the non-certifying structural analysis. */
+function validateCanvasSpec(version, canvas = {}) {
+  return analyzeCanvasDamage(version, canvas);
+}
+
+/** Self-check the fixed profile contract and representative QR geometries. */
+function validateFrameQrTables() {
+  const problems = [];
+  if (FRAMEQR_PROFILE.certified !== false || FRAMEQR_PROFILE.densoFrameQrCompatible !== false) {
+    problems.push('profile compatibility boundary must remain explicitly non-certified');
+  }
+  if (new Set(FRAMEQR_CANVAS_SHAPES).size !== FRAMEQR_CANVAS_SHAPES.length) {
+    problems.push('canvas shape identifiers must be unique');
+  }
+  for (const version of [1, 2, 3, 4, 7, 10, 20, 30, 40]) {
+    const size = versionSize(version);
+    const spec = normalizeCanvasSpec(size);
+    const modules = canvasModules(size, spec);
+    const unique = new Set(modules.map(([x, y]) => `${x},${y}`));
+    if (unique.size !== modules.length) problems.push(`v${version}: duplicate canvas modules`);
+    if (modules.some(([x, y]) => x < 0 || y < 0 || x >= size || y >= size)) {
+      problems.push(`v${version}: canvas escapes the symbol`);
+    }
+    const analysis = analyzeCanvasDamage(version, spec);
+    if (analysis.touchedCodewordsByBlock.length !== blockLayout(version, 'H').blockCount) {
+      problems.push(`v${version}: damage analysis block count mismatch`);
+    }
+  }
+  return problems;
+}
+
+__exports.FRAMEQR_PROFILE = FRAMEQR_PROFILE;
+__exports.FRAMEQR_CANVAS_SHAPES = FRAMEQR_CANVAS_SHAPES;
+__exports.normalizeCanvasSpec = normalizeCanvasSpec;
+__exports.canvasModules = canvasModules;
+__exports.analyzeCanvasDamage = analyzeCanvasDamage;
+__exports.validateCanvasSpec = validateCanvasSpec;
+__exports.validateFrameQrTables = validateFrameQrTables;
+};
+
+__modules["frameqr/encoder.js"] = function (__require, __exports) {
+/**
+ * Sythos Canvas QR profile encoder.
+ *
+ * This encoder deliberately builds on this project's QR Code implementation
+ * and then removes a conservatively bounded set of data modules for artwork.
+ * It is not an implementation of DENSO FrameQR and makes no interoperability
+ * claim for that proprietary format.
+ *
+ * @module frameqr/encoder
+ */
+const { EncodeError } = __require("core/errors.js");
+const { encodeQR } = __require("qr/encoder.js");
+const { FRAMEQR_PROFILE, canvasModules, normalizeCanvasSpec, validateCanvasSpec } = __require("frameqr/tables.js");
+
+/**
+ * @typedef {object} FrameQrEncodeOptions
+ * @property {'H'} [ecc] The profile always uses QR error correction H.
+ * @property {number} [version] Force a QR version 1-40.
+ * @property {number} [mask] Force a QR mask 0-7.
+ * @property {'auto'|'utf-8'|'iso-8859-1'} [charset] Byte mode interpretation.
+ * @property {boolean} [kanji] Allow QR kanji mode.
+ * @property {object} [canvas] Profile artwork reservation.
+ */
+
+function versionFor(matrix) {
+  return (matrix.width - 17) / 4;
+}
+
+function clearCanvas(matrix, modules) {
+  for (const [x, y] of modules) matrix.unset(x, y);
+}
+
+/**
+ * Encode a QR Code with a conservative artwork canvas according to the
+ * non-certified Sythos Canvas QR profile.
+ *
+ * The profile forces QR H error correction and rejects a canvas whenever its
+ * known codeword damage exceeds the per-block correction budget. When a
+ * version is not forced, the smallest QR version that holds both payload and
+ * safe canvas is selected. A decoder can reconstruct the reserved modules from
+ * the returned profile metadata.
+ *
+ * @param {string} text
+ * @param {FrameQrEncodeOptions} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix}
+ * @throws {EncodeError} When the QR payload/options are invalid or the canvas
+ *   cannot safely fit the selected QR version.
+ */
+function encodeFrameQR(text, options = {}) {
+  if (typeof text !== 'string') {
+    throw new EncodeError('Sythos Canvas QR: text must be a string');
+  }
+  if (options.ecc !== undefined && options.ecc !== 'H') {
+    throw new EncodeError('Sythos Canvas QR: ecc is fixed to H for this profile');
+  }
+
+  const qrOptions = {
+    mask: options.mask,
+    charset: options.charset,
+    kanji: options.kanji,
+    ecc: 'H',
+  };
+  for (const key of Object.keys(qrOptions)) {
+    if (qrOptions[key] === undefined) delete qrOptions[key];
+  }
+
+  const versions = options.version === undefined
+    ? Array.from({ length: 40 }, (_, index) => index + 1)
+    : [options.version];
+  let capacityError = null;
+  let unsafeAnalysis = null;
+  let selected = null;
+
+  for (const version of versions) {
+    let matrix;
+    try {
+      matrix = encodeQR(text, { ...qrOptions, version });
+    } catch (error) {
+      capacityError = error;
+      continue;
+    }
+
+    let canvas;
+    let analysis;
+    try {
+      canvas = normalizeCanvasSpec(matrix.width, options.canvas);
+      analysis = validateCanvasSpec(versionFor(matrix), canvas);
+    } catch (error) {
+      if (error instanceof EncodeError) throw error;
+      throw new EncodeError(`Sythos Canvas QR: invalid canvas: ${error.message}`);
+    }
+    if (!analysis.safe) {
+      unsafeAnalysis = analysis;
+      continue;
+    }
+    selected = { matrix, canvas };
+    break;
+  }
+
+  if (!selected) {
+    if (unsafeAnalysis) {
+      throw new EncodeError(
+        'Sythos Canvas QR: canvas is not safe for the selected QR version; ' +
+        `it touches ${unsafeAnalysis.touchedCodewordCount} codewords and has ` +
+        `a per-block correction budget of ${unsafeAnalysis.correctionBudgetPerBlock}`
+      );
+    }
+    if (capacityError) throw capacityError;
+    throw new EncodeError('Sythos Canvas QR: unable to select a QR version');
+  }
+
+  const { matrix, canvas } = selected;
+  clearCanvas(matrix, canvasModules(matrix.width, canvas));
+  matrix.frameqr = {
+    profile: FRAMEQR_PROFILE.id,
+    certified: false,
+    canvas,
+  };
+  return matrix;
+}
+
+__exports.encodeFrameQR = encodeFrameQR;
+};
+
+__modules["frameqr/decoder.js"] = function (__require, __exports) {
+/**
+ * Decoder for the Sythos Canvas QR profile.
+ *
+ * This is intentionally not a DENSO FrameQR decoder. The profile is a QR
+ * symbol with a bounded artwork reservation and an explicit `frameqr` marker.
+ * A normal QR matrix is rejected unless a detector (or another trusted
+ * caller) supplies the profile and explicitly opts in to an unmarked matrix.
+ *
+ * The QR decoder is deliberately kept as the single payload decoder. It can
+ * repair the bounded modules removed for the canvas because the encoder fixes
+ * error correction to H and validates the reservation before clearing it.
+ *
+ * @module frameqr/decoder
+ */
+const { FormatError } = __require("core/errors.js");
+const { decodeQR } = __require("qr/decoder.js");
+const { FRAMEQR_PROFILE, normalizeCanvasSpec, validateCanvasSpec, analyzeCanvasDamage } = __require("frameqr/tables.js");
+
+/** @param {unknown} value @returns {boolean} */
+function isObject(value) {
+  return value !== null && typeof value === 'object';
+}
+
+/**
+ * Return the profile marker attached by the encoder. Older callers sometimes
+ * use camel case, so accepting it here is harmless while the emitted marker
+ * remains the canonical `frameqr` property.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @returns {object|null}
+ */
+function markerOf(matrix) {
+  const marker = matrix && (matrix.frameqr ?? matrix.frameQR);
+  return isObject(marker) ? marker : null;
+}
+
+/** @param {unknown} profile @returns {boolean} */
+function isExpectedProfile(profile) {
+  if (profile === FRAMEQR_PROFILE.id) return true;
+  return isObject(profile) && profile.id === FRAMEQR_PROFILE.id;
+}
+
+/**
+ * Normalize and validate the canvas metadata. Validation functions in the
+ * table module throw on invalid input; a few consumers also return `false` or
+ * a problem list, so those forms are handled defensively here.
+ *
+ * @param {number} symbolSize
+ * @param {number} version
+ * @param {object} canvas
+ * @returns {{canvas: object, damage: object}}
+ */
+function validateCanvas(symbolSize, version, canvas) {
+  if (!isObject(canvas)) throw new FormatError('Sythos Canvas QR: canvas metadata is missing');
+
+  let normalized;
+  try {
+    normalized = normalizeCanvasSpec(symbolSize, canvas);
+    const validation = validateCanvasSpec(version, normalized);
+    if (
+      validation === false ||
+      (Array.isArray(validation) && validation.length > 0) ||
+      (isObject(validation) && validation.valid === false) ||
+      (isObject(validation) && validation.safe === false)
+    ) {
+      throw new Error('canvas geometry is outside the profile limits');
+    }
+  } catch (error) {
+    if (error instanceof FormatError) throw error;
+    throw new FormatError(`Sythos Canvas QR: invalid canvas metadata: ${error.message}`);
+  }
+
+  let damage;
+  try {
+    damage = analyzeCanvasDamage(version, normalized);
+  } catch (error) {
+    throw new FormatError(`Sythos Canvas QR: cannot analyse canvas damage: ${error.message}`);
+  }
+  return { canvas: normalized, damage };
+}
+
+/**
+ * Resolve the profile marker and canvas from the matrix/options pair.
+ *
+ * `allowUnmarked` is deliberately opt-in. It exists for a detector that has
+ * already verified the canvas signature after sampling a photograph; it is
+ * not enabled by the public default and therefore cannot silently relabel an
+ * ordinary QR Code as FrameQR.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {object} options
+ * @returns {{profile: string, canvas: object, damage: object, certified: false}}
+ */
+function resolveProfile(matrix, options) {
+  const marker = markerOf(matrix);
+  const suppliedProfile = options.profile;
+  const markerProfile = marker ? marker.profile : undefined;
+  if (markerProfile !== undefined && suppliedProfile !== undefined) {
+    const markerId = isObject(markerProfile) ? markerProfile.id : markerProfile;
+    const suppliedId = isObject(suppliedProfile) ? suppliedProfile.id : suppliedProfile;
+    if (markerId !== suppliedId) {
+      throw new FormatError('Sythos Canvas QR: matrix and requested profile markers disagree');
+    }
+  }
+  const profile = markerProfile ?? suppliedProfile;
+
+  if (!isExpectedProfile(profile)) {
+    throw new FormatError(
+      'Sythos Canvas QR: profile marker is missing or is not the Sythos Canvas QR profile'
+    );
+  }
+  if (marker && marker.certified === true) {
+    throw new FormatError(
+      'Sythos Canvas QR: certified FrameQR input is not supported by this profile decoder'
+    );
+  }
+  if (!marker && !options.allowUnmarked) {
+    throw new FormatError(
+      'Sythos Canvas QR: unmarked QR matrix rejected; provide a verified profile marker'
+    );
+  }
+
+  const markerCanvas = marker ? marker.canvas : undefined;
+  const canvas = options.canvas ?? markerCanvas;
+  const version = (matrix.width - 17) / 4;
+  if (!Number.isInteger(version) || version < 1 || version > 40) {
+    throw new FormatError(`Sythos Canvas QR: invalid QR symbol size ${matrix.width}`);
+  }
+  const checked = validateCanvas(matrix.width, version, canvas);
+  if (markerCanvas && options.canvas) {
+    let marked;
+    try {
+      marked = normalizeCanvasSpec(matrix.width, markerCanvas);
+    } catch (error) {
+      throw new FormatError(`Sythos Canvas QR: invalid marker canvas: ${error.message}`);
+    }
+    const fields = ['shape', 'centerX', 'centerY', 'width', 'height', 'angle'];
+    if (fields.some((field) => marked[field] !== checked.canvas[field])) {
+      throw new FormatError('Sythos Canvas QR: matrix and requested canvas metadata disagree');
+    }
+  }
+  return {
+    profile: FRAMEQR_PROFILE.id,
+    canvas: checked.canvas,
+    damage: checked.damage,
+    certified: false,
+  };
+}
+
+/**
+ * Decode a Sythos Canvas QR matrix.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ *   Square QR modules, normally returned by `encodeFrameQR` or a FrameQR
+ *   detector. The encoder's `frameqr` metadata is required by default.
+ * @param {object} [options]
+ * @param {object} [options.canvas] Explicit canvas metadata for a sampled
+ *   matrix when the source marker was not preserved.
+ * @param {string|object} [options.profile] Expected profile identifier.
+ * @param {boolean} [options.allowUnmarked=false] Explicit detector opt-in for
+ *   a matrix whose marker was lost during image sampling.
+ * @returns {import('../qr/decoder.js').DecodeResult & {
+ *   format: 'frameqr', profile: string, certified: false,
+ *   frame: object, canvas: object, canvasDamage: object
+ * }}
+ * @throws {FormatError} If the profile marker/canvas is invalid or the input
+ *   is an ordinary QR Code.
+ */
+function decodeFrameQR(matrix, options = {}) {
+  if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) {
+    throw new FormatError('Sythos Canvas QR: no matrix supplied');
+  }
+  if (matrix.width !== matrix.height) {
+    throw new FormatError(
+      `Sythos Canvas QR: symbol must be square, got ${matrix.width}x${matrix.height}`
+    );
+  }
+
+  const profile = resolveProfile(matrix, options);
+  let decoded;
+  try {
+    decoded = decodeQR(matrix);
+  } catch (error) {
+    // Preserve the original QR/RS error when possible, but give callers a
+    // profile-specific context without exposing implementation details.
+    if (error instanceof FormatError) {
+      throw new FormatError(`Sythos Canvas QR: payload is not recoverable: ${error.message}`);
+    }
+    throw error;
+  }
+
+  return {
+    ...decoded,
+    format: 'frameqr',
+    profile: profile.profile,
+    certified: profile.certified,
+    frame: profile.canvas,
+    canvas: profile.canvas,
+    canvasDamage: profile.damage,
+  };
+}
+__exports.isExpectedProfile = isExpectedProfile;
+
+__exports.decodeFrameQR = decodeFrameQR;
+};
+
+__modules["frameqr/detector.js"] = function (__require, __exports) {
+/**
+ * Detector for the non-certified Sythos Canvas QR profile.
+ *
+ * The profile deliberately reuses QR Model 2 geometry. Finder localisation and
+ * projective sampling therefore use the QR detector; the additional profile
+ * check is the light canvas signature. A sampled image cannot carry the
+ * encoder's in-memory marker, so the detector reconstructs the expected
+ * metadata, verifies that every reserved canvas module is light, and only then
+ * opts into the profile decoder. This rejects ordinary QR symbols whose centre
+ * merely happens to contain a plausible payload.
+ *
+ * Detection is verified for clean binarized rasters, integer scaling, quiet
+ * zones, and in-plane quarter turns. Arbitrary photographic perspective is not
+ * claimed by this module.
+ *
+ * @module frameqr/detector
+ */
+const { NotFoundError } = __require("core/errors.js");
+const { sampleQuad } = __require("image/grid-sampler.js");
+const { detectQR } = __require("qr/detector.js");
+const { decodeFrameQR } = __require("frameqr/decoder.js");
+const { FRAMEQR_PROFILE, canvasModules, normalizeCanvasSpec } = __require("frameqr/tables.js");
+
+/** @typedef {{x:number, y:number}} Point */
+
+/** @typedef {object} FrameQRDetection
+ * @property {Point[]} corners Outer corners in reading order.
+ * @property {number} dimension QR modules per side.
+ * @property {number} version QR Model 2 version.
+ * @property {number} moduleSize Estimated pixels per module.
+ * @property {number} rotation Clockwise in-plane orientation in degrees.
+ * @property {BitMatrix} matrix Rectified profile matrix.
+ * @property {object} canvas Normalized canvas specification.
+ * @property {string} profile Profile identifier.
+ * @property {false} certified Always false for this implementation.
+ */
+
+function orientationDegrees(corners) {
+  const [tl, tr] = corners;
+  const angle = Math.atan2(tr.y - tl.y, tr.x - tl.x) * 180 / Math.PI;
+  return ((Math.round(angle / 90) * 90) % 360 + 360) % 360;
+}
+/**
+ * Return the number of canvas modules that are dark in a sampled matrix.
+ *
+ * Encoded profile symbols clear the whole reserved canvas. A non-zero count
+ * means either a normal QR symbol or a raster whose canvas was overwritten by
+ * artwork; both are rejected because decoding that image would be speculative.
+ */
+function canvasDarkCount(matrix, canvas) {
+  let dark = 0;
+  for (const [x, y] of canvasModules(matrix.width, canvas)) {
+    if (matrix.get(x, y)) dark++;
+  }
+  return dark;
+}
+
+function sameCandidate(left, right) {
+  if (left.dimension !== right.dimension) return false;
+  const a = left.corners[0];
+  const b = right.corners[0];
+  return Math.hypot(a.x - b.x, a.y - b.y) <= Math.max(left.moduleSize, right.moduleSize) * 2;
+}
+
+/**
+ * Detect Sythos Canvas QR symbols in a binarized raster.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @param {object} [options]
+ * @param {object} [options.canvas] Explicit canvas metadata for non-default
+ *   shapes/size. Without it, the profile's canonical centered square is used.
+ * @param {boolean} [options.voting=false] Use majority sampling per module.
+ * @returns {FrameQRDetection[]} Best candidate first; empty when no verified
+ *   profile signature is found.
+ */
+function detectFrameQR(binaryImage, options = {}) {
+  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+    throw new NotFoundError('detectFrameQR: no image supplied');
+  }
+
+  let candidates;
+  try { candidates = detectQR(binaryImage); } catch { return []; }
+  const detections = [];
+
+  for (const candidate of candidates) {
+    // QR detector dimensions are already constrained to legal Model 2 sizes.
+    let canvas;
+    try { canvas = normalizeCanvasSpec(candidate.dimension, options.canvas); }
+    catch { continue; }
+
+    for (const voting of [Boolean(options.voting), !Boolean(options.voting)]) {
+      let matrix;
+      try { matrix = sampleQuad(binaryImage, candidate.dimension, candidate.corners, voting); }
+      catch { continue; }
+
+      // The signature check is intentionally strict. It prevents an ordinary
+      // QR symbol from being relabelled as Canvas QR by the decoder's explicit
+      // allowUnmarked escape hatch.
+      if (canvasDarkCount(matrix, canvas) !== 0) continue;
+
+      const marked = matrix;
+      marked.frameqr = {
+        profile: FRAMEQR_PROFILE.id,
+        certified: false,
+        canvas,
+      };
+      let decoded;
+      try {
+        decoded = decodeFrameQR(marked, {
+          profile: FRAMEQR_PROFILE.id,
+          canvas,
+          allowUnmarked: true,
+        });
+      } catch { continue; }
+
+      const detection = {
+        corners: candidate.corners,
+        dimension: candidate.dimension,
+        version: candidate.version,
+        moduleSize: candidate.moduleSize,
+        rotation: orientationDegrees(candidate.corners),
+        matrix: marked,
+        canvas,
+        profile: FRAMEQR_PROFILE.id,
+        certified: false,
+        result: decoded,
+      };
+      if (!detections.some((entry) => sameCandidate(entry, detection))) detections.push(detection);
+      break;
+    }
+  }
+
+  detections.sort((a, b) => b.moduleSize - a.moduleSize);
+  return detections;
+}
+
+/**
+ * Detect and decode all verified Canvas QR symbols in one call.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @param {object} [options]
+ * @returns {Array<object>}
+ */
+function detectAndDecodeFrameQR(binaryImage, options = {}) {
+  let detections;
+  try { detections = detectFrameQR(binaryImage, options); } catch { return []; }
+  const results = [];
+  const seen = new Set();
+  for (const detection of detections) {
+    const result = detection.result;
+    const key = `${result.version}|${result.text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({ ...result, corners: detection.corners, rotation: detection.rotation });
+  }
+  return results;
+}
+
+__exports.detectFrameQR = detectFrameQR;
+__exports.detectAndDecodeFrameQR = detectAndDecodeFrameQR;
+};
+
+__modules["frameqr/index.js"] = function (__require, __exports) {
+const __reexport0 = __require("frameqr/encoder.js"); __exports.encodeFrameQR = __reexport0.encodeFrameQR;
+const __reexport1 = __require("frameqr/decoder.js"); __exports.decodeFrameQR = __reexport1.decodeFrameQR;
+const __reexport2 = __require("frameqr/detector.js"); __exports.detectFrameQR = __reexport2.detectFrameQR; __exports.detectAndDecodeFrameQR = __reexport2.detectAndDecodeFrameQR;
+const __reexport3 = __require("frameqr/tables.js"); __exports.FRAMEQR_PROFILE = __reexport3.FRAMEQR_PROFILE; __exports.FRAMEQR_CANVAS_SHAPES = __reexport3.FRAMEQR_CANVAS_SHAPES; __exports.canvasModules = __reexport3.canvasModules; __exports.normalizeCanvasSpec = __reexport3.normalizeCanvasSpec; __exports.analyzeCanvasDamage = __reexport3.analyzeCanvasDamage; __exports.validateCanvasSpec = __reexport3.validateCanvasSpec; __exports.validateFrameQrTables = __reexport3.validateFrameQrTables;
+
+
+};
+
+__modules["aztecrune/tables.js"] = function (__require, __exports) {
+/**
+ * Aztec Rune geometry.
+ *
+ * Aztec Rune is the 11x11, one-byte member of the Aztec family. Two 4-bit
+ * data words and five 4-bit Reed-Solomon check words are XORed with the fixed
+ * Aztec Rune mask and written clockwise on the outer data ring. The finder and
+ * corner orientation marks are independent of the value.
+ *
+ * The constants below are derived from the public Aztec Code specification and
+ * are kept separate from the general Aztec implementation so a normal Aztec
+ * decoder can never accidentally treat an 11x11 Rune as a regular symbol.
+ *
+ * @module aztecrune/tables
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { fieldForWordSize } = __require("aztec/tables.js");
+const AZTEC_RUNE_SIZE = 11;
+const AZTEC_RUNE_DATA_BITS = 8;
+const AZTEC_RUNE_WORD_SIZE = 4;
+const AZTEC_RUNE_DATA_CODEWORDS = 2;
+const AZTEC_RUNE_ECC_CODEWORDS = 5;
+const AZTEC_RUNE_TOTAL_CODEWORDS = AZTEC_RUNE_DATA_CODEWORDS + AZTEC_RUNE_ECC_CODEWORDS;
+const AZTEC_RUNE_MASK = 0b1010;
+
+/**
+ * Data-module coordinates in wire order: clockwise, starting at the top.
+ * Every side contributes seven modules, for 28 bits in total.
+ */
+const AZTEC_RUNE_DATA_POSITIONS = Object.freeze([
+  ...Array.from({ length: 7 }, (_, i) => [i + 2, 0]),
+  ...Array.from({ length: 7 }, (_, i) => [10, i + 2]),
+  ...Array.from({ length: 7 }, (_, i) => [8 - i, 10]),
+  ...Array.from({ length: 7 }, (_, i) => [0, 8 - i]),
+].map(([x, y]) => Object.freeze([x, y])));
+
+const DATA_KEYS = new Set(AZTEC_RUNE_DATA_POSITIONS.map(([x, y]) => `${x},${y}`));
+
+/** @param {number} x @param {number} y @returns {boolean} */
+function isAztecRuneDataPosition(x, y) {
+  return DATA_KEYS.has(`${x},${y}`);
+}
+/**
+ * Return the value of a structural module. Data positions return `null`.
+ * The bull's-eye has five square rings including its one-module centre; its
+ * even-radius rings are dark. The four corner groups are the orientation marks
+ * described by the Aztec Rune specification.
+ *
+ * @param {number} x @param {number} y
+ * @returns {boolean|null}
+ */
+function aztecRuneStructuralValue(x, y) {
+  if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= AZTEC_RUNE_SIZE || y >= AZTEC_RUNE_SIZE) {
+    return null;
+  }
+  if (isAztecRuneDataPosition(x, y)) return null;
+
+  const distance = Math.max(Math.abs(x - 5), Math.abs(y - 5));
+  if (distance <= 4) return (distance & 1) === 0;
+
+  // Corner orientation groups, clockwise from the upper-left corner:
+  // three dark, white-dark-dark, dark-white-white, three white.
+  if ((x === 0 && y <= 1) || (y === 0 && x <= 1)) return true;
+  if ((x === 10 && y <= 1) || (y === 0 && x === 10)) return true;
+  if (x === 9 && y === 0) return false;
+  if (x === 10 && y === 10) return false;
+  if (y === 10 && x >= 0 && x <= 1) return false;
+  if (x === 0 && y >= 9) return false;
+  if (x === 10 && y === 9) return true;
+
+  // All non-data cells are covered by the bull's-eye or the four corners.
+  return false;
+}
+
+/** Build only the fixed finder/orientation structure. */
+function buildAztecRuneStructure() {
+  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 value = aztecRuneStructuralValue(x, y);
+      if (value === true) matrix.set(x, y);
+    }
+  }
+  return matrix;
+}
+
+/** Return the field used by Rune data/check words. */
+function aztecRuneField() {
+  return fieldForWordSize(AZTEC_RUNE_WORD_SIZE);
+}
+
+/** Validate the fixed Rune contract and coordinate layout. */
+function validateAztecRuneTables() {
+  const problems = [];
+  if (AZTEC_RUNE_SIZE !== 11) problems.push('Rune symbol size must be 11');
+  if (AZTEC_RUNE_TOTAL_CODEWORDS * AZTEC_RUNE_WORD_SIZE !== 28) problems.push('Rune outer ring must carry 28 bits');
+  if (AZTEC_RUNE_DATA_POSITIONS.length !== 28) problems.push('Rune data ring must contain 28 modules');
+  if (new Set(AZTEC_RUNE_DATA_POSITIONS.map(([x, y]) => `${x},${y}`)).size !== 28) problems.push('Rune data coordinates must be unique');
+  const structure = buildAztecRuneStructure();
+  for (let y = 0; y < AZTEC_RUNE_SIZE; y++) for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+    if (isAztecRuneDataPosition(x, y)) continue;
+    const expected = aztecRuneStructuralValue(x, y) === true;
+    if (structure.get(x, y) !== expected) problems.push(`Rune structure mismatch at ${x},${y}`);
+  }
+  return problems;
+}
+
+__exports.AZTEC_RUNE_SIZE = AZTEC_RUNE_SIZE;
+__exports.AZTEC_RUNE_DATA_BITS = AZTEC_RUNE_DATA_BITS;
+__exports.AZTEC_RUNE_WORD_SIZE = AZTEC_RUNE_WORD_SIZE;
+__exports.AZTEC_RUNE_DATA_CODEWORDS = AZTEC_RUNE_DATA_CODEWORDS;
+__exports.AZTEC_RUNE_ECC_CODEWORDS = AZTEC_RUNE_ECC_CODEWORDS;
+__exports.AZTEC_RUNE_TOTAL_CODEWORDS = AZTEC_RUNE_TOTAL_CODEWORDS;
+__exports.AZTEC_RUNE_MASK = AZTEC_RUNE_MASK;
+__exports.AZTEC_RUNE_DATA_POSITIONS = AZTEC_RUNE_DATA_POSITIONS;
+__exports.isAztecRuneDataPosition = isAztecRuneDataPosition;
+__exports.aztecRuneStructuralValue = aztecRuneStructuralValue;
+__exports.buildAztecRuneStructure = buildAztecRuneStructure;
+__exports.aztecRuneField = aztecRuneField;
+__exports.validateAztecRuneTables = validateAztecRuneTables;
+};
+
+__modules["aztecrune/encoder.js"] = function (__require, __exports) {
+/**
+ * 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
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { rsEncode } = __require("core/reed-solomon.js");
+const { AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, buildAztecRuneStructure } = __require("aztecrune/tables.js");
+
+/** @param {unknown} value @returns {number} */
+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');
+}
+
+/** @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);
+}
+
+/** @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);
+    }
+  }
+}
+
+/**
+ * Encode one byte as an Aztec Rune.
+ *
+ * @param {number|string|ArrayBuffer|ArrayBufferView} value
+ * @param {{inverted?: boolean}} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix & {
+ *   format: 'aztecrune', value: number, inverted: boolean
+ * }}
+ */
+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;
+}
+__exports.codewordsForValue = codewordsForValue;
+
+__exports.normalizeAztecRuneValue = normalizeAztecRuneValue;
+__exports.encodeAztecRune = encodeAztecRune;
+};
+
+__modules["aztecrune/decoder.js"] = function (__require, __exports) {
+/**
+ * Aztec Rune decoder.
+ *
+ * The input is a square 11x11 module matrix. Structural modules are checked
+ * before the seven masked GF(16) codewords are Reed-Solomon corrected. The
+ * decoder tries the four in-plane quarter turns and both polarities, allowing
+ * it to consume an oriented sampled image while still rejecting ordinary
+ * Aztec/QR matrices.
+ *
+ * @module aztecrune/decoder
+ */
+const { FormatError } = __require("core/errors.js");
+const { rsDecode } = __require("core/reed-solomon.js");
+const { AZTEC_RUNE_DATA_CODEWORDS, AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, aztecRuneStructuralValue } = __require("aztecrune/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);
+    }
+    current = out;
+  }
+  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;
+}
+
+/** @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;
+}
+
+/** @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);
+}
+
+/** @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,
+  };
+}
+
+/**
+ * Decode a square Aztec Rune matrix.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {{inverted?: boolean|'auto', rotation?: number|'auto'}} [options]
+ * @returns {{format:'aztecrune',value:number,text:string,bytes:Uint8Array,dimension:number,inverted:boolean,rotation:number,corrections:number}}
+ * @throws {FormatError} For non-Rune geometry, structure or uncorrectable data.
+ */
+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 (checksumError) {
+    throw new FormatError(`Aztec Rune: Reed-Solomon check failed: ${checksumError.message}`);
+  }
+  throw new FormatError('Aztec Rune: structural pattern or orientation is invalid');
+}
+__exports.readCodewords = readCodewords; __exports.structureMatches = structureMatches;
+
+__exports.decodeAztecRune = decodeAztecRune;
+};
+
+__modules["aztecrune/detector.js"] = function (__require, __exports) {
+/**
+ * Detector for Aztec Rune symbols.
+ *
+ * Rune has a fixed 11x11 geometry and a distinctive five-ring bull's-eye. This
+ * detector targets binarized, module-aligned rasters (including an integer
+ * scale, quiet zone and quarter turns). Arbitrary perspective and severe blur
+ * remain detector-level limitations; callers needing those conditions should
+ * pass a rectified 11x11 matrix to decodeAztecRune.
+ *
+ * @module aztecrune/detector
+ */
+const { NotFoundError } = __require("core/errors.js");
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { decodeAztecRune } = __require("aztecrune/decoder.js");
+const { AZTEC_RUNE_SIZE } = __require("aztecrune/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
+ * returning the light background as a candidate while retaining an inverted
+ * 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 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);
+}
+/** @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;
+}
+
+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 },
+  ];
+}
+
+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;
+}
+
+/**
+ * Detect the most prominent Aztec Rune in a binarized image.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {{corners:Point[],dimension:11,moduleSize:number,matrix:BitMatrix,result:object}|null}
+ */
+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);
+    }
+  }
+  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. */
+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 };
+}
+
+__exports.detectAztecRune = detectAztecRune;
+__exports.detectAndDecodeAztecRune = detectAndDecodeAztecRune;
+};
+
+__modules["aztecrune/index.js"] = function (__require, __exports) {
+/** Aztec Rune entry points. @module aztecrune */
+const __reexport0 = __require("aztecrune/encoder.js"); __exports.encodeAztecRune = __reexport0.encodeAztecRune; __exports.normalizeAztecRuneValue = __reexport0.normalizeAztecRuneValue;
+const __reexport1 = __require("aztecrune/decoder.js"); __exports.decodeAztecRune = __reexport1.decodeAztecRune;
+const __reexport2 = __require("aztecrune/detector.js"); __exports.detectAztecRune = __reexport2.detectAztecRune; __exports.detectAndDecodeAztecRune = __reexport2.detectAndDecodeAztecRune;
+const __reexport3 = __require("aztecrune/tables.js"); __exports.AZTEC_RUNE_SIZE = __reexport3.AZTEC_RUNE_SIZE; __exports.AZTEC_RUNE_DATA_BITS = __reexport3.AZTEC_RUNE_DATA_BITS; __exports.AZTEC_RUNE_WORD_SIZE = __reexport3.AZTEC_RUNE_WORD_SIZE; __exports.AZTEC_RUNE_DATA_CODEWORDS = __reexport3.AZTEC_RUNE_DATA_CODEWORDS; __exports.AZTEC_RUNE_ECC_CODEWORDS = __reexport3.AZTEC_RUNE_ECC_CODEWORDS; __exports.AZTEC_RUNE_TOTAL_CODEWORDS = __reexport3.AZTEC_RUNE_TOTAL_CODEWORDS; __exports.AZTEC_RUNE_MASK = __reexport3.AZTEC_RUNE_MASK; __exports.AZTEC_RUNE_DATA_POSITIONS = __reexport3.AZTEC_RUNE_DATA_POSITIONS; __exports.aztecRuneStructuralValue = __reexport3.aztecRuneStructuralValue; __exports.buildAztecRuneStructure = __reexport3.buildAztecRuneStructure; __exports.aztecRuneField = __reexport3.aztecRuneField; __exports.validateAztecRuneTables = __reexport3.validateAztecRuneTables;
+
+
+};
+
+__modules["compactpdf417/tables.js"] = function (__require, __exports) {
+/**
+ * Compact (truncated) PDF417 layout.
+ *
+ * Compact PDF417 is a geometric variant of PDF417, not a new high-level
+ * compaction mode. It keeps the same codeword, cluster, row-indicator,
+ * Reed–Solomon and Text/Byte/Numeric compaction rules, while omitting each
+ * row's right row indicator and replacing the normal stop pattern with a
+ * single dark module. The resulting symbol remains distinguishable from the
+ * ordinary PDF417 layout by its width and row terminator.
+ *
+ * @module compactpdf417/tables
+ */
+const { EncodeError } = __require("core/errors.js");
+
+/** PDF417 start pattern, in module widths. */
+const COMPACT_PDF417_START = '81111113';
+
+/** Binary module representation of the start pattern. */
+const COMPACT_PDF417_START_BITS = '11111111010101000';
+
+/** Compact PDF417's reduced stop is one dark module. */
+const COMPACT_PDF417_STOP_MODULES = 1;
+
+/** Minimum/maximum number of rows and data columns. */
+const COMPACT_PDF417_LIMITS = Object.freeze({
+  minRows: 3,
+  maxRows: 90,
+  minColumns: 1,
+  maxColumns: 30,
+  maxCodewords: 928,
+});
+
+/**
+ * Return the printed width in modules for a compact symbol.
+ *
+ * 17 start + 17 left indicator + 17 per codeword column + 1 reduced stop.
+ * @param {number} columns
+ */
+function compactPdf417Width(columns) {
+  if (!Number.isInteger(columns) || columns < 1 || columns > 30) {
+    throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+  }
+  return 35 + columns * 17;
+}
+
+/**
+ * Validate a compact matrix geometry and return its dimensions.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} rowHeight
+ */
+function compactPdf417Geometry(width, height, rowHeight = 3) {
+  if (!Number.isInteger(width) || !Number.isInteger(height)) {
+    throw new RangeError('Compact PDF417: matrix dimensions must be integers');
+  }
+  if (!Number.isInteger(rowHeight) || rowHeight < 1) {
+    throw new RangeError('Compact PDF417: rowHeight must be a positive integer');
+  }
+  if ((width - 35) % 17 !== 0) {
+    throw new RangeError(`Compact PDF417: width ${width} does not match the compact layout`);
+  }
+  const columns = (width - 35) / 17;
+  const rows = height / rowHeight;
+  if (!Number.isInteger(rows) || rows < 3 || rows > 90) {
+    throw new RangeError(`Compact PDF417: rows must be an integer in 3..90, got ${rows}`);
+  }
+  if (columns < 1 || columns > 30) {
+    throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+  }
+  return { rows, columns, rowHeight, width, height };
+}
+
+/**
+ * Validate encoder dimensions before codeword packing.
+ * @param {object} options
+ */
+function validateCompactPdf417Options(options = {}) {
+  const { minRows, maxRows, minColumns, maxColumns } = COMPACT_PDF417_LIMITS;
+  const rowHeight = options.rowHeight ?? 3;
+  if (!Number.isInteger(rowHeight) || rowHeight < 3) {
+    throw new EncodeError('Compact PDF417: rowHeight must be an integer of at least 3');
+  }
+  for (const [name, value, min, max] of [
+    ['rows', options.rows, minRows, maxRows],
+    ['columns', options.columns, minColumns, maxColumns],
+  ]) {
+    if (value !== undefined && (!Number.isInteger(value) || value < min || value > max)) {
+      throw new EncodeError(`Compact PDF417: ${name} must be an integer in ${min}..${max}`);
+    }
+  }
+  if (options.aspectRatio !== undefined &&
+      (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) {
+    throw new EncodeError('Compact PDF417: aspectRatio must be positive');
+  }
+  return rowHeight;
+}
+
+/**
+ * The row indicator values used by ordinary PDF417 are retained unchanged.
+ * Compact symbols omit only the right indicator, so the left indicator still
+ * carries the row group, row count, error-correction level and column count.
+ */
+function compactPdf417Indicators(row, rows, columns, level) {
+  const group = Math.floor(row / 3);
+  const y = Math.floor((rows - 1) / 3);
+  const z = level * 3 + (rows - 1) % 3;
+  const v = columns - 1;
+  if (row % 3 === 0) return 30 * group + y;
+  if (row % 3 === 1) return 30 * group + z;
+  return 30 * group + v;
+}
+
+/**
+ * Return all standard ECC levels which agree with the observed left
+ * indicators. This is kept as a table helper so decoder and tests share the
+ * same compact-layout rule.
+ */
+function compactPdf417MatchingLevels(leftIndicators, rows, columns) {
+  const matches = [];
+  for (let level = 0; level <= 8; level++) {
+    if (leftIndicators.every((value, row) =>
+      value === compactPdf417Indicators(row, rows, columns, level))) matches.push(level);
+  }
+  return matches;
+}
+
+/** Validate representative layout invariants. */
+function validateCompactPdf417Tables() {
+  const problems = [];
+  for (const columns of [1, 2, 3, 10, 30]) {
+    const width = compactPdf417Width(columns);
+    if (width !== 35 + columns * 17) problems.push(`columns ${columns}: width mismatch`);
+  }
+  for (const rows of [3, 4, 5, 6, 90]) {
+    const left = Array.from({ length: rows }, (_, row) => compactPdf417Indicators(row, rows, 3, 2));
+    if (compactPdf417MatchingLevels(left, rows, 3).length !== 1) {
+      problems.push(`rows ${rows}: row indicators do not identify one ECC level`);
+    }
+  }
+  return problems;
+}
+
+__exports.COMPACT_PDF417_START = COMPACT_PDF417_START;
+__exports.COMPACT_PDF417_START_BITS = COMPACT_PDF417_START_BITS;
+__exports.COMPACT_PDF417_STOP_MODULES = COMPACT_PDF417_STOP_MODULES;
+__exports.COMPACT_PDF417_LIMITS = COMPACT_PDF417_LIMITS;
+__exports.compactPdf417Width = compactPdf417Width;
+__exports.compactPdf417Geometry = compactPdf417Geometry;
+__exports.validateCompactPdf417Options = validateCompactPdf417Options;
+__exports.compactPdf417Indicators = compactPdf417Indicators;
+__exports.compactPdf417MatchingLevels = compactPdf417MatchingLevels;
+__exports.validateCompactPdf417Tables = validateCompactPdf417Tables;
+};
+
+__modules["compactpdf417/encoder.js"] = function (__require, __exports) {
+/** Compact PDF417 (truncated PDF417) encoder. @module compactpdf417/encoder */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { compactPdf417 } = __require("pdf417/compaction.js");
+const { pdf417ErrorCorrection, pdf417EccLength } = __require("pdf417/error-correction.js");
+const { pdf417PatternForCodeword } = __require("pdf417/tables.js");
+const { COMPACT_PDF417_START, compactPdf417Indicators, compactPdf417Width, validateCompactPdf417Options } = __require("compactpdf417/tables.js");
+
+function appendWidths(matrix, y, x, sequence, height) {
+  let dark = true;
+  for (const digit of sequence) {
+    const width = digit.charCodeAt(0) - 48;
+    if (!Number.isInteger(width) || width < 1 || width > 8) {
+      throw new EncodeError('Compact PDF417: invalid module-width sequence');
+    }
+    if (dark) matrix.setRegion(x, y, width, height);
+    x += width;
+    dark = !dark;
+  }
+  return x;
+}
+
+function patternSequence(pattern) {
+  return pattern.toString(2).padStart(17, '0').replace(/0+|1+/g, (run) => String(run.length));
+}
+
+function dimensions(needed, level, options, rowHeight) {
+  const ecc = pdf417EccLength(level);
+  let best = null;
+  for (let rows = options.rows ?? 3; rows <= (options.rows ?? 90); rows++) {
+    for (let columns = options.columns ?? 1; columns <= (options.columns ?? 30); columns++) {
+      if (rows * columns > 928 || rows * columns - ecc < needed) continue;
+      const ratio = compactPdf417Width(columns) / (rows * rowHeight);
+      const score = (rows * columns - ecc - needed) * 10 +
+        Math.abs(ratio - (options.aspectRatio ?? 3));
+      if (!best || score < best.score) best = { rows, columns, score };
+    }
+  }
+  if (!best) {
+    throw new EncodeError(
+      'Compact PDF417: payload does not fit the requested dimensions and error correction level'
+    );
+  }
+  return best;
+}
+
+/**
+ * Encode Compact PDF417.
+ *
+ * High-level Text/Byte/Numeric compaction is intentionally delegated to the
+ * existing PDF417 compaction implementation. `compact` here describes only
+ * the physical truncated layout: right row indicators are omitted and the
+ * stop pattern is reduced to one dark module.
+ *
+ * @param {string|Uint8Array|number[]} value
+ * @param {object} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix}
+ */
+function encodeCompactPDF417(value, options = {}) {
+  const rowHeight = validateCompactPdf417Options(options);
+  const level = options.eccLevel ?? 2;
+  if (!Number.isInteger(level) || level < 0 || level > 8) {
+    throw new EncodeError('Compact PDF417: eccLevel must be an integer in 0..8');
+  }
+
+  const payload = compactPdf417(value, { compaction: options.compaction, charset: options.charset });
+  const { rows, columns } = dimensions(payload.length + 1, level, options, rowHeight);
+  const eccLength = pdf417EccLength(level);
+  const dataLength = rows * columns - eccLength;
+  const data = [dataLength, ...payload];
+  while (data.length < dataLength) data.push(900);
+  const codewords = data.concat(pdf417ErrorCorrection(data, level));
+
+  const matrix = new BitMatrix(compactPdf417Width(columns), rows * rowHeight);
+  for (let row = 0; row < rows; row++) {
+    const y = row * rowHeight;
+    const cluster = (row % 3) * 3;
+    let x = appendWidths(matrix, y, 0, COMPACT_PDF417_START, rowHeight);
+    const left = compactPdf417Indicators(row, rows, columns, level);
+    x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(left, cluster)), rowHeight);
+    for (let column = 0; column < columns; column++) {
+      const codeword = codewords[row * columns + column];
+      x = appendWidths(matrix, y, x,
+        patternSequence(pdf417PatternForCodeword(codeword, cluster)), rowHeight);
+    }
+    // Compact PDF417 terminates every row with one dark module, not the normal
+    // right indicator plus 18-module stop pattern.
+    matrix.setRegion(x, y, 1, rowHeight);
+    x++;
+    if (x !== matrix.width) throw new EncodeError('Compact PDF417: internal row width mismatch');
+  }
+
+  matrix.compactPdf417 = {
+    rows,
+    columns,
+    eccLevel: level,
+    rowHeight,
+    codewords,
+    layout: 'compact',
+  };
+  return matrix;
+}
+__exports.compactPdf417Dimensions = dimensions;
+
+__exports.encodeCompactPDF417 = encodeCompactPDF417;
+};
+
+__modules["compactpdf417/decoder.js"] = function (__require, __exports) {
+/** Compact PDF417 decoder. @module compactpdf417/decoder */
+const { FormatError } = __require("core/errors.js");
+const { decodePdf417CompactionDetailed } = __require("pdf417/compaction.js");
+const { pdf417CorrectErrors, pdf417EccLength } = __require("pdf417/error-correction.js");
+const { pdf417CodewordForPattern } = __require("pdf417/tables.js");
+const { COMPACT_PDF417_START_BITS, compactPdf417Geometry, compactPdf417Indicators, compactPdf417MatchingLevels } = __require("compactpdf417/tables.js");
+
+function bits(matrix, y, x, width) {
+  let value = 0;
+  for (let index = 0; index < width; index++) value = (value << 1) | (matrix.get(x + index, y) ? 1 : 0);
+  return value;
+}
+
+function patternString(matrix, y, x, width) {
+  return bits(matrix, y, x, width).toString(2).padStart(width, '0');
+}
+
+/**
+ * Decode a compact/truncated PDF417 module matrix.
+ *
+ * The high-level payload uses the normal PDF417 Text/Byte/Numeric compaction
+ * rules. This function only changes the physical row parser: no right row
+ * indicator is expected and the final module of each row must be dark.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {object} [options]
+ * @param {number} [options.rowHeight]
+ */
+function decodeCompactPDF417(matrix, options = {}) {
+  if (!matrix?.width || !matrix?.height) throw new FormatError('Compact PDF417: no matrix supplied');
+  const rowHeight = options.rowHeight ?? matrix.compactPdf417?.rowHeight ?? 3;
+  let geometry;
+  try { geometry = compactPdf417Geometry(matrix.width, matrix.height, rowHeight); }
+  catch (error) { throw new FormatError(error.message); }
+
+  const { rows, columns } = geometry;
+  const all = [];
+  const erasures = [];
+  const leftIndicators = [];
+
+  for (let row = 0; row < rows; row++) {
+    const y = row * rowHeight;
+    if (patternString(matrix, y, 0, 17) !== COMPACT_PDF417_START_BITS) {
+      throw new FormatError('Compact PDF417: missing start pattern');
+    }
+    const cluster = (row % 3) * 3;
+    const leftDecoded = pdf417CodewordForPattern(bits(matrix, y, 17, 17));
+    if (!leftDecoded || leftDecoded.cluster !== cluster) {
+      throw new FormatError('Compact PDF417: invalid left row indicator');
+    }
+    leftIndicators.push(leftDecoded.codeword);
+
+    const dataStart = 34;
+    const stopX = dataStart + columns * 17;
+    if (!matrix.get(stopX, y)) throw new FormatError('Compact PDF417: missing reduced stop module');
+    for (let column = 0; column < columns; column++) {
+      const decoded = pdf417CodewordForPattern(bits(matrix, y, dataStart + column * 17, 17));
+      if (!decoded || decoded.cluster !== cluster) {
+        erasures.push(all.length);
+        all.push(0);
+      } else {
+        all.push(decoded.codeword);
+      }
+    }
+  }
+
+  const levels = compactPdf417MatchingLevels(leftIndicators, rows, columns);
+  if (levels.length !== 1) throw new FormatError('Compact PDF417: row indicator mismatch');
+  const level = levels[0];
+  const eccLength = pdf417EccLength(level);
+  if (all.length <= eccLength) throw new FormatError('Compact PDF417: insufficient codewords for ECC');
+
+  const corrected = all.slice();
+  const corrections = pdf417CorrectErrors(corrected, level, erasures);
+  const length = corrected[0];
+  if (length < 1 || length > corrected.length - eccLength) {
+    throw new FormatError('Compact PDF417: invalid symbol length descriptor');
+  }
+  const payload = corrected.slice(1, length);
+  const decoded = decodePdf417CompactionDetailed(payload);
+  return {
+    ...decoded,
+    format: 'compact-pdf417',
+    compact: true,
+    codewords: corrected,
+    rows,
+    columns,
+    eccLevel: level,
+    rowHeight,
+    corrections,
+  };
+}
+
+__exports.decodeCompactPDF417 = decodeCompactPDF417;
+};
+
+__modules["compactpdf417/detector.js"] = function (__require, __exports) {
+/** Compact PDF417 detector for clean, integer-scaled rasters. @module compactpdf417/detector */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { compactPdf417Width } = __require("compactpdf417/tables.js");
+const { decodeCompactPDF417 } = __require("compactpdf417/decoder.js");
+
+function rotateClockwise(source) {
+  const out = new BitMatrix(source.height, source.width);
+  for (let y = 0; y < source.height; y++) {
+    for (let x = 0; x < source.width; x++) {
+      if (source.get(x, y)) out.set(source.height - 1 - y, x);
+    }
+  }
+  return out;
+}
+function cropAndDownsample(source, box, width, height, scale) {
+  const out = new BitMatrix(width, height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let dark = 0;
+      for (let dy = 0; dy < scale; dy++) {
+        for (let dx = 0; dx < scale; dx++) {
+          if (source.get(box.x + x * scale + dx, box.y + y * scale + dy)) dark++;
+        }
+      }
+      if (dark * 2 >= scale * scale) out.set(x, y);
+    }
+  }
+  return out;
+}
+
+function cornersFor(box) {
+  return [
+    { x: box.x, y: box.y },
+    { x: box.x + box.width, y: box.y },
+    { x: box.x + box.width, y: box.y + box.height },
+    { x: box.x, y: box.y + box.height },
+  ];
+}
+
+function mapCorners(corners, toOriginal) {
+  return corners.map((point) => toOriginal(point));
+}
+
+/**
+ * Detect one Compact PDF417 symbol in a binarized raster.
+ *
+ * The clean-raster detector uses the dark bounding box and enumerates legal
+ * compact widths, integer module scales, row counts and row heights. It is
+ * deliberately conservative: arbitrary perspective, non-integer resampling,
+ * grayscale thresholding and damaged stop bars belong to a future photo
+ * detector and are not claimed here.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @param {object} [options]
+ * @param {number} [options.rowHeight] Restrict the row-height search.
+ * @returns {object|null}
+ */
+function detectCompactPDF417(binaryImage, options = {}) {
+  if (!binaryImage?.width || !binaryImage?.height || typeof binaryImage.get !== 'function') return null;
+
+  let oriented = binaryImage;
+  let toOriginal = (point) => ({ x: point.x, y: point.y });
+  for (let rotation = 0; rotation < 4; rotation++) {
+    const bounds = oriented.getBounds();
+    if (bounds) {
+      for (let columns = 1; columns <= 30; columns++) {
+        const width = compactPdf417Width(columns);
+        const scale = bounds.width / width;
+        if (!Number.isInteger(scale) || scale < 1) continue;
+        const baseHeight = bounds.height / scale;
+        const rowHeights = Number.isInteger(options.rowHeight)
+          ? [options.rowHeight]
+          : Array.from({ length: 18 }, (_, index) => index + 3);
+        for (const rowHeight of rowHeights) {
+          if (!Number.isInteger(baseHeight / rowHeight)) continue;
+          const rows = baseHeight / rowHeight;
+          if (rows < 3 || rows > 90) continue;
+          const matrix = cropAndDownsample(oriented, bounds, width, baseHeight, scale);
+          try {
+            const result = decodeCompactPDF417(matrix, { rowHeight });
+            const corners = mapCorners(cornersFor(bounds), toOriginal);
+            return {
+              ...result,
+              matrix,
+              corners,
+              rotation: rotation * 90,
+              moduleSize: scale,
+              compact: true,
+            };
+          } catch {
+            // Try another geometry; a standard PDF417 or random artwork should
+            // never be accepted unless the compact decoder validates every row.
+          }
+        }
+      }
+    }
+
+    const previous = oriented;
+    const previousToOriginal = toOriginal;
+    oriented = rotateClockwise(previous);
+    toOriginal = (point) => previousToOriginal({ x: point.y, y: previous.height - point.x });
+  }
+  return null;
+}
+function detectAndDecodeCompactPDF417(binaryImage, options = {}) {
+  return detectCompactPDF417(binaryImage, options);
+}
+
+__exports.detectCompactPDF417 = detectCompactPDF417;
+__exports.detectAndDecodeCompactPDF417 = detectAndDecodeCompactPDF417;
+};
+
+__modules["compactpdf417/index.js"] = function (__require, __exports) {
+/* Compact PDF417 public module exports. */
+const __reexport0 = __require("compactpdf417/tables.js"); __exports.COMPACT_PDF417_START = __reexport0.COMPACT_PDF417_START; __exports.COMPACT_PDF417_START_BITS = __reexport0.COMPACT_PDF417_START_BITS; __exports.COMPACT_PDF417_STOP_MODULES = __reexport0.COMPACT_PDF417_STOP_MODULES; __exports.COMPACT_PDF417_LIMITS = __reexport0.COMPACT_PDF417_LIMITS; __exports.compactPdf417Width = __reexport0.compactPdf417Width; __exports.compactPdf417Geometry = __reexport0.compactPdf417Geometry; __exports.compactPdf417Indicators = __reexport0.compactPdf417Indicators; __exports.compactPdf417MatchingLevels = __reexport0.compactPdf417MatchingLevels; __exports.validateCompactPdf417Options = __reexport0.validateCompactPdf417Options; __exports.validateCompactPdf417Tables = __reexport0.validateCompactPdf417Tables;
+const __reexport1 = __require("compactpdf417/encoder.js"); __exports.encodeCompactPDF417 = __reexport1.encodeCompactPDF417; __exports.compactPdf417Dimensions = __reexport1.compactPdf417Dimensions;
+const __reexport2 = __require("compactpdf417/decoder.js"); __exports.decodeCompactPDF417 = __reexport2.decodeCompactPDF417;
+const __reexport3 = __require("compactpdf417/detector.js"); __exports.detectCompactPDF417 = __reexport3.detectCompactPDF417; __exports.detectAndDecodeCompactPDF417 = __reexport3.detectAndDecodeCompactPDF417;
+
+
+};
+
+__modules["databar/tables.js"] = function (__require, __exports) {
+/**
+ * Static GS1 DataBar facts used by the GTIN compaction codec.
+ *
+ * The numbers in the DataBar-14 group tables are the public tables in
+ * ISO/IEC 24724:2011, clauses 5.2.2 and 5.2.3. They describe values, not a
+ * third-party implementation. Pattern construction deliberately belongs in
+ * the renderer/encoder layer so this module stays a small, auditable contract.
+ *
+ * @module databar/tables
+ */
+
+const group = (first, last, gsum, oddModules, evenModules, oddWidest, evenWidest, oddTotal, evenTotal) => Object.freeze({
+  first, last, gsum, oddModules, evenModules, oddWidest, evenWidest, oddTotal, evenTotal,
+});
+
+/** The four GTIN-only layouts sharing the DataBar-14 compaction rules. */
+const DATABAR14_VARIANTS = Object.freeze({
+  omnidirectional: Object.freeze({ id: 'omnidirectional', rows: 1, modules: 96, checksumModulus: 79, pointOfSale: true }),
+  truncated: Object.freeze({ id: 'truncated', rows: 1, modules: 96, checksumModulus: 79, pointOfSale: false }),
+  stacked: Object.freeze({ id: 'stacked', rows: 2, modules: 50, checksumModulus: 79, pointOfSale: false }),
+  'stacked-omnidirectional': Object.freeze({ id: 'stacked-omnidirectional', rows: 2, modules: 50, checksumModulus: 79, pointOfSale: true }),
+});
+
+/** GS1 DataBar Limited is a distinct two-character symbology. */
+const DATABAR_LIMITED_VARIANT = Object.freeze({
+  id: 'limited', rows: 1, checksumModulus: 89, pointOfSale: false,
+  permittedIndicatorDigits: Object.freeze([0, 1]),
+});
+
+/** (16,4) outside character groups, ISO/IEC 24724:2011 Table 1. */
+const DATABAR14_OUTSIDE_GROUPS = Object.freeze([
+  group(0, 160, 0, 12, 4, 8, 1, 161, 1),
+  group(161, 960, 161, 10, 6, 6, 3, 80, 10),
+  group(961, 2014, 961, 8, 8, 4, 5, 31, 34),
+  group(2015, 2714, 2015, 6, 10, 3, 6, 10, 70),
+  group(2715, 2840, 2715, 4, 12, 1, 8, 1, 126),
+]);
+
+/** (15,4) inside character groups, ISO/IEC 24724:2011 Table 2. */
+const DATABAR14_INSIDE_GROUPS = Object.freeze([
+  group(0, 335, 0, 5, 10, 2, 7, 4, 84),
+  group(336, 1035, 336, 7, 8, 4, 5, 20, 35),
+  group(1036, 1515, 1036, 9, 6, 6, 3, 48, 10),
+  group(1516, 1596, 1516, 11, 4, 8, 1, 81, 1),
+]);
+
+/** Number of values carried by an inside (15,4) character. */
+const DATABAR14_INSIDE_RADIX = 1597;
+/** Number of values carried by one outside/inside character pair. */
+const DATABAR14_PAIR_RADIX = 4537077;
+/** Stand-alone and composite DataBar-14 payload domain, including linkage. */
+const DATABAR14_SYMBOL_LIMIT = 20000000000000n;
+
+/** GS1 DataBar Limited divides its 13 data digits into two character values. */
+const DATABAR_LIMITED_PAIR_RADIX = 2013571;
+/** Offset that switches a DataBar Limited value from stand-alone to composite. */
+const DATABAR_LIMITED_LINKAGE_OFFSET = 2015133531096n;
+/** DataBar Limited carries GTIN values whose first digit is zero or one. */
+const DATABAR_LIMITED_DATA_LIMIT = 2000000000000n;
+
+/** Locate the value group that an outside or inside character belongs to. */
+function dataBar14GroupFor(value, kind) {
+  if (!Number.isInteger(value)) throw new TypeError('GS1 DataBar character value must be an integer');
+  const groups = kind === 'outside' ? DATABAR14_OUTSIDE_GROUPS
+    : kind === 'inside' ? DATABAR14_INSIDE_GROUPS : null;
+  if (!groups) throw new RangeError(`Unknown GS1 DataBar character kind "${kind}"`);
+  const found = groups.find((entry) => value >= entry.first && value <= entry.last);
+  if (!found) throw new RangeError(`GS1 DataBar ${kind} character value ${value} is out of range`);
+  return found;
+}
+/** Check the independently represented table identities. */
+function validateDataBarTables() {
+  const problems = [];
+  const validateGroups = (name, groups, expectedLast) => {
+    let next = 0;
+    for (const entry of groups) {
+      if (entry.first !== next) problems.push(`${name}: gap before ${entry.first}`);
+      if (entry.last < entry.first) problems.push(`${name}: inverted range ${entry.first}-${entry.last}`);
+      if (entry.oddTotal * entry.evenTotal !== entry.last - entry.first + 1) {
+        problems.push(`${name}: combination count mismatch at ${entry.first}`);
+      }
+      next = entry.last + 1;
+    }
+    if (next - 1 !== expectedLast) problems.push(`${name}: final value is ${next - 1}, expected ${expectedLast}`);
+  };
+  validateGroups('outside', DATABAR14_OUTSIDE_GROUPS, 2840);
+  validateGroups('inside', DATABAR14_INSIDE_GROUPS, 1596);
+  if (DATABAR14_PAIR_RADIX !== 2841 * DATABAR14_INSIDE_RADIX) problems.push('pair radix mismatch');
+  if (DATABAR14_SYMBOL_LIMIT !== 2n * 10000000000000n) problems.push('symbol limit mismatch');
+  if (DATABAR_LIMITED_LINKAGE_OFFSET !== BigInt(DATABAR_LIMITED_PAIR_RADIX) * 1000776n) {
+    problems.push('limited linkage offset mismatch');
+  }
+  return problems;
+}
+
+__exports.DATABAR14_VARIANTS = DATABAR14_VARIANTS;
+__exports.DATABAR_LIMITED_VARIANT = DATABAR_LIMITED_VARIANT;
+__exports.DATABAR14_OUTSIDE_GROUPS = DATABAR14_OUTSIDE_GROUPS;
+__exports.DATABAR14_INSIDE_GROUPS = DATABAR14_INSIDE_GROUPS;
+__exports.DATABAR14_INSIDE_RADIX = DATABAR14_INSIDE_RADIX;
+__exports.DATABAR14_PAIR_RADIX = DATABAR14_PAIR_RADIX;
+__exports.DATABAR14_SYMBOL_LIMIT = DATABAR14_SYMBOL_LIMIT;
+__exports.DATABAR_LIMITED_PAIR_RADIX = DATABAR_LIMITED_PAIR_RADIX;
+__exports.DATABAR_LIMITED_LINKAGE_OFFSET = DATABAR_LIMITED_LINKAGE_OFFSET;
+__exports.DATABAR_LIMITED_DATA_LIMIT = DATABAR_LIMITED_DATA_LIMIT;
+__exports.dataBar14GroupFor = dataBar14GroupFor;
+__exports.validateDataBarTables = validateDataBarTables;
+};
+
+__modules["databar/codec.js"] = function (__require, __exports) {
+/**
+ * GTIN validation and numeric compaction for GS1 DataBar GTIN-only symbols.
+ *
+ * This is intentionally not a bar-pattern encoder. It emits the exact symbol
+ * character values required by ISO/IEC 24724:2011; a later encoder can turn
+ * those values into widths without reinterpreting a GTIN or linkage flag.
+ *
+ * @module databar/codec
+ */
+const { DATABAR14_INSIDE_RADIX, DATABAR14_PAIR_RADIX, DATABAR14_SYMBOL_LIMIT, DATABAR_LIMITED_DATA_LIMIT, DATABAR_LIMITED_LINKAGE_OFFSET, DATABAR_LIMITED_PAIR_RADIX } = __require("databar/tables.js");
+
+const GTIN_LENGTHS = new Set([8, 12, 13, 14]);
+
+function digits(value, label) {
+  const text = String(value);
+  if (!/^\d+$/.test(text)) throw new TypeError(`${label} must contain only decimal digits`);
+  return text;
+}
+
+function asCharacterValue(value, label, maximum) {
+  if (!Number.isInteger(value) || value < 0 || value > maximum) {
+    throw new RangeError(`${label} must be an integer from 0 to ${maximum}`);
+  }
+  return value;
+}
+
+/** Calculate the GS1 modulo-10 check digit for a GTIN body. */
+function gtinCheckDigit(body) {
+  const text = digits(body, 'GTIN body');
+  if (text.length < 1 || text.length > 13) throw new RangeError('GTIN body must contain 1 to 13 digits');
+  let sum = 0;
+  for (let i = text.length - 1, weight = 3; i >= 0; i--, weight = weight === 3 ? 1 : 3) {
+    sum += Number(text[i]) * weight;
+  }
+  return String((10 - (sum % 10)) % 10);
+}
+
+/** Return a checked 14-digit GTIN, preserving only its standardized digits. */
+function normalizeGTIN(value) {
+  const input = digits(value, 'GTIN');
+  if (!GTIN_LENGTHS.has(input.length)) {
+    throw new RangeError('GTIN must contain 8, 12, 13, or 14 digits including its check digit');
+  }
+  if (gtinCheckDigit(input.slice(0, -1)) !== input.at(-1)) {
+    throw new RangeError(`GTIN check digit is invalid for ${input}`);
+  }
+  return input.padStart(14, '0');
+}
+
+/** Build a checked GTIN-14 from its thirteen-digit data body. */
+function makeGTIN14(body) {
+  const input = digits(body, 'GTIN-14 body');
+  if (input.length > 13) throw new RangeError('GTIN-14 body must contain at most 13 digits');
+  const padded = input.padStart(13, '0');
+  return padded + gtinCheckDigit(padded);
+}
+
+function gtinFromSymbolValue(symbolValue) {
+  const value = BigInt(symbolValue);
+  if (value < 0n || value >= DATABAR14_SYMBOL_LIMIT) throw new RangeError('GS1 DataBar-14 symbol value is out of range');
+  const linkage = value >= 10000000000000n;
+  const body = (linkage ? value - 10000000000000n : value).toString().padStart(13, '0');
+  return { linkage, gtin: body + gtinCheckDigit(body) };
+}
+
+/**
+ * Compact a GTIN into the four values shared by Omnidirectional, Truncated,
+ * Stacked and Stacked Omnidirectional. The `physicalCharacters` sequence is
+ * left-to-right on a linear DataBar-14 row: 1, 2, 4, 3.
+ */
+function encodeDataBar14GTIN(value, options = {}) {
+  const gtin = normalizeGTIN(value);
+  const linkage = options.linkage === true;
+  if (options.linkage !== undefined && typeof options.linkage !== 'boolean') {
+    throw new TypeError('GS1 DataBar linkage must be a boolean');
+  }
+  const dataBody = gtin.slice(0, -1);
+  const symbolValue = BigInt(dataBody) + (linkage ? 10000000000000n : 0n);
+  const leftPair = symbolValue / BigInt(DATABAR14_PAIR_RADIX);
+  const rightPair = symbolValue % BigInt(DATABAR14_PAIR_RADIX);
+  const outerLeft = Number(leftPair / BigInt(DATABAR14_INSIDE_RADIX));
+  const innerLeft = Number(leftPair % BigInt(DATABAR14_INSIDE_RADIX));
+  const outerRight = Number(rightPair / BigInt(DATABAR14_INSIDE_RADIX));
+  const innerRight = Number(rightPair % BigInt(DATABAR14_INSIDE_RADIX));
+
+  return Object.freeze({
+    gtin, linkage, symbolValue, leftPair, rightPair,
+    logicalCharacters: Object.freeze({ outerLeft, innerLeft, outerRight, innerRight }),
+    physicalCharacters: Object.freeze([outerLeft, innerLeft, innerRight, outerRight]),
+  });
+}
+
+/** Reconstruct and validate a GTIN from the four DataBar-14 character values. */
+function decodeDataBar14GTIN(values) {
+  if (values === null || typeof values !== 'object') throw new TypeError('GS1 DataBar-14 characters must be an object');
+  const outerLeft = asCharacterValue(values.outerLeft, 'outerLeft', 2840);
+  const innerLeft = asCharacterValue(values.innerLeft, 'innerLeft', 1596);
+  const outerRight = asCharacterValue(values.outerRight, 'outerRight', 2840);
+  const innerRight = asCharacterValue(values.innerRight, 'innerRight', 1596);
+  const leftPair = BigInt(outerLeft) * BigInt(DATABAR14_INSIDE_RADIX) + BigInt(innerLeft);
+  const rightPair = BigInt(outerRight) * BigInt(DATABAR14_INSIDE_RADIX) + BigInt(innerRight);
+  return Object.freeze({
+    ...gtinFromSymbolValue(leftPair * BigInt(DATABAR14_PAIR_RADIX) + rightPair),
+    leftPair, rightPair,
+  });
+}
+
+/** Compact a DataBar Limited-eligible GTIN into its two data character values. */
+function encodeDataBarLimitedGTIN(value, options = {}) {
+  const gtin = normalizeGTIN(value);
+  const linkage = options.linkage === true;
+  if (options.linkage !== undefined && typeof options.linkage !== 'boolean') {
+    throw new TypeError('GS1 DataBar linkage must be a boolean');
+  }
+  const dataBody = BigInt(gtin.slice(0, -1));
+  if (dataBody >= DATABAR_LIMITED_DATA_LIMIT) {
+    throw new RangeError('GS1 DataBar Limited requires a GTIN whose indicator digit is 0 or 1');
+  }
+  const symbolValue = dataBody + (linkage ? DATABAR_LIMITED_LINKAGE_OFFSET : 0n);
+  const left = Number(symbolValue / BigInt(DATABAR_LIMITED_PAIR_RADIX));
+  const right = Number(symbolValue % BigInt(DATABAR_LIMITED_PAIR_RADIX));
+  return Object.freeze({ gtin, linkage, symbolValue, left, right });
+}
+
+/** Reconstruct and validate a GTIN from DataBar Limited data character values. */
+function decodeDataBarLimitedGTIN(values) {
+  if (values === null || typeof values !== 'object') throw new TypeError('GS1 DataBar Limited characters must be an object');
+  const left = asCharacterValue(values.left, 'left', 1994036);
+  const right = asCharacterValue(values.right, 'right', DATABAR_LIMITED_PAIR_RADIX - 1);
+  let symbolValue = BigInt(left) * BigInt(DATABAR_LIMITED_PAIR_RADIX) + BigInt(right);
+  const linkage = symbolValue >= DATABAR_LIMITED_LINKAGE_OFFSET;
+  if (linkage) symbolValue -= DATABAR_LIMITED_LINKAGE_OFFSET;
+  if (symbolValue < 0n || symbolValue >= DATABAR_LIMITED_DATA_LIMIT) {
+    throw new RangeError('GS1 DataBar Limited character values do not encode a permitted GTIN');
+  }
+  const body = symbolValue.toString().padStart(13, '0');
+  return Object.freeze({ linkage, gtin: body + gtinCheckDigit(body), symbolValue: BigInt(left) * BigInt(DATABAR_LIMITED_PAIR_RADIX) + BigInt(right) });
+}
+
+/** GS1 transmitted form for the GTIN-only DataBar variants. */
+function dataBarGtinTransmission(value) {
+  return `]e001${normalizeGTIN(value)}`;
+}
+
+__exports.gtinCheckDigit = gtinCheckDigit;
+__exports.normalizeGTIN = normalizeGTIN;
+__exports.makeGTIN14 = makeGTIN14;
+__exports.encodeDataBar14GTIN = encodeDataBar14GTIN;
+__exports.decodeDataBar14GTIN = decodeDataBar14GTIN;
+__exports.encodeDataBarLimitedGTIN = encodeDataBarLimitedGTIN;
+__exports.decodeDataBarLimitedGTIN = decodeDataBarLimitedGTIN;
+__exports.dataBarGtinTransmission = dataBarGtinTransmission;
+};
+
+__modules["databar/gs1.js"] = function (__require, __exports) {
+/** GS1 element-string codec used by GS1 DataBar Expanded. @module databar/gs1 */
+const { EncodeError, FormatError } = __require("core/errors.js");
+const GS1_SEPARATOR = '\x1d';
+
+const EXACT = new Map([
+  ['00', [18, true]], ['01', [14, true]], ['02', [14, true]],
+  ['10', [20, false]], ['11', [6, true]], ['12', [6, true]],
+  ['13', [6, true]], ['15', [6, true]], ['16', [6, true]],
+  ['17', [6, true]], ['20', [2, true]], ['21', [20, false]],
+  ['22', [29, false]], ['30', [8, false]], ['37', [8, false]],
+  ['240', [30, false]], ['241', [30, false]], ['242', [6, false]],
+  ['243', [20, false]], ['250', [30, false]], ['251', [30, false]],
+  ['253', [30, false]], ['254', [20, false]], ['255', [13, true]],
+  ['400', [30, false]], ['401', [30, false]], ['402', [17, true]],
+  ['403', [30, false]], ['410', [13, true]], ['411', [13, true]],
+  ['412', [13, true]], ['413', [13, true]], ['414', [13, true]],
+  ['415', [13, true]], ['416', [13, true]], ['417', [13, true]],
+  ['420', [20, false]], ['421', [15, false]], ['422', [3, true]],
+  ['423', [15, false]], ['424', [3, true]], ['425', [3, true]],
+  ['426', [3, true]], ['427', [3, false]],
+  ['7001', [13, true]], ['7002', [30, false]], ['7003', [10, true]],
+  ['7004', [4, false]], ['7005', [12, false]], ['7006', [6, true]],
+  ['7007', [12, false]], ['7008', [3, false]], ['7009', [10, false]],
+  ['7010', [2, false]], ['7020', [20, false]], ['7021', [20, false]],
+  ['7022', [20, false]], ['710', [20, false]], ['711', [20, false]],
+  ['712', [20, false]], ['713', [20, false]], ['714', [20, false]],
+  ['715', [20, false]],
+  ['8001', [14, true]], ['8002', [20, false]], ['8003', [30, false]],
+  ['8004', [30, false]], ['8005', [6, true]], ['8006', [18, true]],
+  ['8007', [34, false]], ['8008', [12, false]], ['8009', [50, false]],
+  ['8010', [30, false]], ['8011', [12, false]], ['8012', [20, false]],
+  ['8013', [30, false]], ['8017', [18, true]], ['8018', [18, true]],
+  ['8019', [10, false]], ['8020', [25, false]], ['8026', [18, true]],
+  ['8110', [70, false]], ['8111', [4, true]], ['8112', [70, false]],
+  ['8200', [70, false]],
+]);
+
+function rangedAI(ai) {
+  if (/^31[0-6]\d$/.test(ai) || /^32[0-7]\d$/.test(ai) ||
+      /^33[0-7]\d$/.test(ai) || /^34[0-9]\d$/.test(ai) ||
+      /^35[0-7]\d$/.test(ai) || /^36[0-9]\d$/.test(ai)) return [6, true];
+  if (/^390\d$/.test(ai) || /^392\d$/.test(ai)) return [15, false];
+  if (/^391\d$/.test(ai) || /^393\d$/.test(ai)) return [18, false];
+  if (/^394\d$/.test(ai)) return [4, true];
+  if (/^395\d$/.test(ai)) return [6, true];
+  if (/^703\d$/.test(ai) || /^723\d$/.test(ai)) return [30, false];
+  return undefined;
+}
+function gs1AIInfo(ai) {
+  if (typeof ai !== 'string' || !/^\d{2,4}$/.test(ai)) return undefined;
+  const spec = EXACT.get(ai) || rangedAI(ai);
+  if (!spec) return undefined;
+  return { ai, length: spec[0], fixed: spec[1] };
+}
+
+function assertCharacters(value, label, ErrorType) {
+  if (/[^\x20-\x7e]/.test(value)) {
+    throw new ErrorType(`GS1: ${label} contains a character outside the GS1 element-string character set`);
+  }
+}
+
+function validateElement(ai, value, ErrorType) {
+  const info = gs1AIInfo(ai);
+  if (!info) throw new ErrorType(`GS1: unsupported or invalid Application Identifier ${ai}`);
+  if (value.length === 0) throw new ErrorType(`GS1: AI ${ai} must not be empty`);
+  if (info.fixed ? value.length !== info.length : value.length > info.length) {
+    const expectation = info.fixed ? `exactly ${info.length}` : `at most ${info.length}`;
+    throw new ErrorType(`GS1: AI ${ai} requires ${expectation} characters`);
+  }
+  assertCharacters(value, `AI ${ai}`, ErrorType);
+  return { ai, value, fixed: info.fixed };
+}
+function parseGS1ElementString(input) {
+  if (typeof input !== 'string' || input.length === 0) {
+    throw new EncodeError('GS1: element string must be a non-empty string');
+  }
+  const elements = [];
+  let offset = 0;
+  while (offset < input.length) {
+    const match = /^\((\d{2,4})\)/.exec(input.slice(offset));
+    if (!match) throw new EncodeError(`GS1: expected an Application Identifier at offset ${offset}`);
+    const ai = match[1];
+    offset += match[0].length;
+    const next = input.indexOf('(', offset);
+    const end = next < 0 ? input.length : next;
+    elements.push(validateElement(ai, input.slice(offset, end), EncodeError));
+    offset = end;
+  }
+  return elements;
+}
+function encodeGS1ElementString(input) {
+  const elements = Array.isArray(input)
+    ? input.map(({ ai, value }) => validateElement(String(ai), String(value), EncodeError))
+    : parseGS1ElementString(input);
+  return elements.map((element, index) =>
+    `${element.ai}${element.value}${!element.fixed && index + 1 < elements.length ? GS1_SEPARATOR : ''}`
+  ).join('');
+}
+
+function matchAIAt(data, offset) {
+  for (const length of [4, 3, 2]) {
+    const ai = data.slice(offset, offset + length);
+    if (gs1AIInfo(ai)) return ai;
+  }
+  return undefined;
+}
+function decodeGS1ElementString(data) {
+  if (typeof data !== 'string' || data.length === 0) {
+    throw new FormatError('GS1: encoded data must be a non-empty string');
+  }
+  const elements = [];
+  let offset = 0;
+  while (offset < data.length) {
+    if (data[offset] === GS1_SEPARATOR) {
+      throw new FormatError(`GS1: unexpected separator at offset ${offset}`);
+    }
+    const ai = matchAIAt(data, offset);
+    if (!ai) throw new FormatError(`GS1: unknown Application Identifier at offset ${offset}`);
+    offset += ai.length;
+    const info = gs1AIInfo(ai);
+    let value;
+    if (info.fixed) {
+      value = data.slice(offset, offset + info.length);
+      if (value.length !== info.length || value.includes(GS1_SEPARATOR)) {
+        throw new FormatError(`GS1: truncated fixed-length AI ${ai}`);
+      }
+      offset += info.length;
+    } else {
+      const separator = data.indexOf(GS1_SEPARATOR, offset);
+      const end = separator < 0 ? data.length : separator;
+      value = data.slice(offset, end);
+      offset = separator < 0 ? data.length : separator + 1;
+    }
+    elements.push(validateElement(ai, value, FormatError));
+  }
+  return elements;
+}
+function formatGS1Elements(elements) {
+  return elements.map(({ ai, value }) => `(${ai})${value}`).join('');
+}
+
+__exports.GS1_SEPARATOR = GS1_SEPARATOR;
+__exports.gs1AIInfo = gs1AIInfo;
+__exports.parseGS1ElementString = parseGS1ElementString;
+__exports.encodeGS1ElementString = encodeGS1ElementString;
+__exports.decodeGS1ElementString = decodeGS1ElementString;
+__exports.formatGS1Elements = formatGS1Elements;
+};
+
+__modules["databar/patterns.js"] = function (__require, __exports) {
+/** Mathematical width construction for GS1 DataBar characters. @module databar/patterns */
+const { dataBar14GroupFor } = __require("databar/tables.js");
+
+function combinations(n, r) {
+  if (n < r || r < 0) return 0;
+  if (r === 0 || n === r) return 1;
+  let result = 1;
+  const k = Math.min(r, n - r);
+  for (let i = 1; i <= k; i++) result = result * (n - k + i) / i;
+  return result;
+}
+
+/**
+ * Unrank one constrained positive composition.
+ *
+ * The rank is the GS1 DataBar symbol-character value inside its group. This
+ * implementation follows the combinatorial definition directly: it counts
+ * every remaining admissible suffix rather than storing third-party patterns.
+ */
+function dataBarWidths(rank, modules, elements, maximumWidth, noNarrow) {
+  if (!Number.isInteger(rank) || rank < 0) throw new RangeError('GS1 DataBar width rank must be non-negative');
+  const widths = new Array(elements).fill(0);
+  let remaining = modules;
+  let narrowMask = 0;
+
+  for (let bar = 0; bar < elements - 1; bar++) {
+    let count = 0;
+    for (let width = 1; ; width++) {
+      narrowMask |= width === 1 ? 1 << bar : 0;
+      count = combinations(remaining - width - 1, elements - bar - 2);
+
+      if (noNarrow && narrowMask === 0 && remaining - width - (elements - bar - 1) >= elements - bar - 1) {
+        count -= combinations(remaining - width - (elements - bar), elements - bar - 2);
+      }
+
+      if (elements - bar - 1 > 1) {
+        let tooWide = 0;
+        for (let last = remaining - width - (elements - bar - 2); last > maximumWidth; last--) {
+          tooWide += combinations(remaining - width - last - 1, elements - bar - 3);
+        }
+        count -= tooWide * (elements - 1 - bar);
+      } else if (remaining - width > maximumWidth) {
+        count--;
+      }
+
+      if (rank < count) {
+        widths[bar] = width;
+        remaining -= width;
+        break;
+      }
+      rank -= count;
+      narrowMask &= ~(1 << bar);
+    }
+  }
+  widths[elements - 1] = remaining;
+  if (rank !== 0 || widths.some((width) => width < 1 || width > maximumWidth)) {
+    throw new RangeError('GS1 DataBar width rank exceeds its character group');
+  }
+  return widths;
+}
+
+/** Convert one DataBar-14 character value into its eight alternating widths. */
+function dataBar14CharacterWidths(value, kind) {
+  const group = dataBar14GroupFor(value, kind);
+  const offset = value - group.gsum;
+  const outside = kind === 'outside';
+  const oddRank = outside ? Math.floor(offset / group.evenTotal) : offset % group.oddTotal;
+  const evenRank = outside ? offset % group.evenTotal : Math.floor(offset / group.oddTotal);
+  const odd = dataBarWidths(oddRank, group.oddModules, 4, group.oddWidest, !outside);
+  const even = dataBarWidths(evenRank, group.evenModules, 4, group.evenWidest, outside);
+  const result = [];
+  for (let i = 0; i < 4; i++) result.push(odd[i], even[i]);
+  return result;
+}
+
+const inverseCharacterMaps = new Map();
+
+/** Recover a character value from its canonical eight-width representation. */
+function dataBar14ValueForWidths(widths, kind) {
+  if (!Array.isArray(widths) || widths.length !== 8 || widths.some((width) => !Number.isInteger(width) || width < 1)) {
+    throw new TypeError('GS1 DataBar character widths must contain eight positive integers');
+  }
+  if (kind !== 'outside' && kind !== 'inside') throw new RangeError(`Unknown GS1 DataBar character kind "${kind}"`);
+  let inverse = inverseCharacterMaps.get(kind);
+  if (!inverse) {
+    inverse = new Map();
+    const maximum = kind === 'outside' ? 2840 : 1596;
+    for (let value = 0; value <= maximum; value++) {
+      inverse.set(dataBar14CharacterWidths(value, kind).join(','), value);
+    }
+    inverseCharacterMaps.set(kind, inverse);
+  }
+  const value = inverse.get(widths.join(','));
+  if (value === undefined) throw new RangeError(`Invalid GS1 DataBar ${kind} character widths`);
+  return value;
+}
+
+/** Nine finder patterns, expressed as normative five-element widths. */
+const DATABAR14_FINDERS = Object.freeze([
+  Object.freeze([3, 8, 2, 1, 1]), Object.freeze([3, 5, 5, 1, 1]),
+  Object.freeze([3, 3, 7, 1, 1]), Object.freeze([3, 1, 9, 1, 1]),
+  Object.freeze([2, 7, 4, 1, 1]), Object.freeze([2, 5, 6, 1, 1]),
+  Object.freeze([2, 3, 8, 1, 1]), Object.freeze([1, 5, 7, 1, 1]),
+  Object.freeze([1, 3, 9, 1, 1]),
+]);
+
+/** Weight sequence generated as powers of three modulo 79. */
+const DATABAR14_CHECKSUM_WEIGHTS = Object.freeze(Array.from({ length: 32 }, (_, index) => {
+  let value = 1;
+  for (let i = 0; i < index; i++) value = (value * 3) % 79;
+  return value;
+}));
+
+__exports.dataBarWidths = dataBarWidths;
+__exports.dataBar14CharacterWidths = dataBar14CharacterWidths;
+__exports.dataBar14ValueForWidths = dataBar14ValueForWidths;
+__exports.DATABAR14_FINDERS = DATABAR14_FINDERS;
+__exports.DATABAR14_CHECKSUM_WEIGHTS = DATABAR14_CHECKSUM_WEIGHTS;
+};
+
+__modules["databar/encoder.js"] = function (__require, __exports) {
+/** GS1 DataBar Omnidirectional and Truncated encoder. @module databar/encoder */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { encodeDataBar14GTIN } = __require("databar/codec.js");
+const { DATABAR14_CHECKSUM_WEIGHTS, DATABAR14_FINDERS, dataBar14CharacterWidths } = __require("databar/patterns.js");
+
+function finderIndexes(characters) {
+  const widths = characters.map((value, index) =>
+    dataBar14CharacterWidths(value, index === 0 || index === 3 ? 'outside' : 'inside')
+  );
+  let checksum = 0;
+  const weightOffsets = [0, 8, 24, 16];
+  for (let character = 0; character < 4; character++) {
+    for (let element = 0; element < 8; element++) {
+      checksum += widths[character][element] * DATABAR14_CHECKSUM_WEIGHTS[weightOffsets[character] + element];
+    }
+  }
+  checksum %= 79;
+  if (checksum >= 8) checksum++;
+  if (checksum >= 72) checksum++;
+  return { widths, checksum, left: Math.floor(checksum / 9), right: checksum % 9 };
+}
+
+function widthsToMatrix(widths, height) {
+  const width = widths.reduce((sum, value) => sum + value, 0);
+  const matrix = new BitMatrix(width, height);
+  let dark = false;
+  let x = 0;
+  for (const run of widths) {
+    if (dark) matrix.setRegion(x, 0, run, height);
+    x += run;
+    dark = !dark;
+  }
+  return matrix;
+}
+
+/** Encode a checked GTIN as DataBar Omnidirectional or Truncated. */
+function encodeDataBar14(value, options = {}) {
+  const variant = options.variant ?? 'omnidirectional';
+  if (variant !== 'omnidirectional' && variant !== 'truncated') {
+    throw new EncodeError('GS1 DataBar-14 physical encoder currently supports omnidirectional and truncated');
+  }
+  const height = options.height ?? (variant === 'omnidirectional' ? 33 : 13);
+  if (!Number.isInteger(height) || height < (variant === 'omnidirectional' ? 33 : 13)) {
+    throw new EncodeError(`GS1 DataBar ${variant} height is below its normative minimum`);
+  }
+  const compacted = encodeDataBar14GTIN(value, { linkage: options.linkage });
+  const characters = compacted.physicalCharacters;
+  const check = finderIndexes(characters);
+  const widths = [1, 1];
+  widths.push(...check.widths[0]);
+  widths.push(...DATABAR14_FINDERS[check.left]);
+  widths.push(...check.widths[1].slice().reverse());
+  widths.push(...check.widths[2]);
+  widths.push(...DATABAR14_FINDERS[check.right].slice().reverse());
+  widths.push(...check.widths[3].slice().reverse());
+  widths.push(1, 1);
+  const matrix = widthsToMatrix(widths, height);
+  matrix.databar = Object.freeze({ variant, gtin: compacted.gtin, linkage: compacted.linkage, checksum: check.checksum });
+  return matrix;
+}
+
+__exports.encodeDataBar14 = encodeDataBar14;
+};
+
+__modules["databar/decoder.js"] = function (__require, __exports) {
+/** Clean-matrix decoder for GS1 DataBar Omnidirectional and Truncated. @module databar/decoder */
+const { ChecksumError, FormatError } = __require("core/errors.js");
+const { decodeDataBar14GTIN } = __require("databar/codec.js");
+const { DATABAR14_CHECKSUM_WEIGHTS, DATABAR14_FINDERS, dataBar14ValueForWidths } = __require("databar/patterns.js");
+
+function sampledRuns(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) {
+    throw new TypeError('GS1 DataBar decoder expects a BitMatrix-like value');
+  }
+  if (matrix.width % 96 !== 0) throw new FormatError('GS1 DataBar-14 matrix width must be an integer multiple of 96 modules');
+  const scale = matrix.width / 96;
+  const y = Math.floor(matrix.height / 2);
+  const bits = Array.from({ length: 96 }, (_, x) => matrix.get(x * scale + Math.floor(scale / 2), y));
+  if (bits[0] || !bits[95]) throw new FormatError('GS1 DataBar-14 guard pattern is invalid');
+  const runs = [];
+  let current = bits[0];
+  let length = 0;
+  for (const bit of bits) {
+    if (bit === current) length++;
+    else {
+      runs.push(length);
+      current = bit;
+      length = 1;
+    }
+  }
+  runs.push(length);
+  if (runs.length !== 46 || runs[0] !== 1 || runs[1] !== 1 || runs[44] !== 1 || runs[45] !== 1) {
+    throw new FormatError('GS1 DataBar-14 element count or guard widths are invalid');
+  }
+  return runs;
+}
+
+function finderIndex(widths) {
+  const key = widths.join(',');
+  return DATABAR14_FINDERS.findIndex((candidate) => candidate.join(',') === key);
+}
+
+function expectedChecksum(widths) {
+  const offsets = [0, 8, 24, 16];
+  let checksum = 0;
+  for (let character = 0; character < 4; character++) {
+    for (let element = 0; element < 8; element++) {
+      checksum += widths[character][element] * DATABAR14_CHECKSUM_WEIGHTS[offsets[character] + element];
+    }
+  }
+  checksum %= 79;
+  if (checksum >= 8) checksum++;
+  if (checksum >= 72) checksum++;
+  return checksum;
+}
+
+/** Decode a clean or integer-scaled 96-module DataBar-14 matrix. */
+function decodeDataBar14(matrix) {
+  const runs = sampledRuns(matrix);
+  const widths = [
+    runs.slice(2, 10),
+    runs.slice(15, 23).slice().reverse(),
+    runs.slice(23, 31),
+    runs.slice(36, 44).slice().reverse(),
+  ];
+  const leftFinder = finderIndex(runs.slice(10, 15));
+  const rightFinder = finderIndex(runs.slice(31, 36).slice().reverse());
+  if (leftFinder < 0 || rightFinder < 0) throw new FormatError('GS1 DataBar-14 finder pattern is invalid');
+  const encodedChecksum = leftFinder * 9 + rightFinder;
+  if (encodedChecksum !== expectedChecksum(widths)) throw new ChecksumError('GS1 DataBar-14 checksum mismatch');
+
+  const outerLeft = dataBar14ValueForWidths(widths[0], 'outside');
+  const innerLeft = dataBar14ValueForWidths(widths[1], 'inside');
+  const innerRight = dataBar14ValueForWidths(widths[2], 'inside');
+  const outerRight = dataBar14ValueForWidths(widths[3], 'outside');
+  const decoded = decodeDataBar14GTIN({ outerLeft, innerLeft, outerRight, innerRight });
+  return Object.freeze({
+    format: 'databar-omnidirectional',
+    text: decoded.gtin,
+    gtin: decoded.gtin,
+    linkage: decoded.linkage,
+    symbologyIdentifier: ']e0',
+  });
+}
+
+__exports.decodeDataBar14 = decodeDataBar14;
+};
+
+__modules["databar/index.js"] = function (__require, __exports) {
+/** Verified GS1 DataBar data-layer primitives. @module databar */
+const __reexport0 = __require("databar/codec.js"); __exports.dataBarGtinTransmission = __reexport0.dataBarGtinTransmission; __exports.decodeDataBar14GTIN = __reexport0.decodeDataBar14GTIN; __exports.decodeDataBarLimitedGTIN = __reexport0.decodeDataBarLimitedGTIN; __exports.encodeDataBar14GTIN = __reexport0.encodeDataBar14GTIN; __exports.encodeDataBarLimitedGTIN = __reexport0.encodeDataBarLimitedGTIN; __exports.gtinCheckDigit = __reexport0.gtinCheckDigit; __exports.makeGTIN14 = __reexport0.makeGTIN14; __exports.normalizeGTIN = __reexport0.normalizeGTIN;
+const __reexport1 = __require("databar/gs1.js"); __exports.GS1_SEPARATOR = __reexport1.GS1_SEPARATOR; __exports.decodeGS1ElementString = __reexport1.decodeGS1ElementString; __exports.encodeGS1ElementString = __reexport1.encodeGS1ElementString; __exports.formatGS1Elements = __reexport1.formatGS1Elements; __exports.gs1AIInfo = __reexport1.gs1AIInfo; __exports.parseGS1ElementString = __reexport1.parseGS1ElementString;
+const __reexport2 = __require("databar/tables.js"); __exports.DATABAR14_VARIANTS = __reexport2.DATABAR14_VARIANTS; __exports.DATABAR_LIMITED_VARIANT = __reexport2.DATABAR_LIMITED_VARIANT; __exports.dataBar14GroupFor = __reexport2.dataBar14GroupFor; __exports.validateDataBarTables = __reexport2.validateDataBarTables;
+const __reexport3 = __require("databar/encoder.js"); __exports.encodeDataBar14 = __reexport3.encodeDataBar14;
+const __reexport4 = __require("databar/decoder.js"); __exports.decodeDataBar14 = __reexport4.decodeDataBar14;
+const __reexport5 = __require("databar/patterns.js"); __exports.DATABAR14_CHECKSUM_WEIGHTS = __reexport5.DATABAR14_CHECKSUM_WEIGHTS; __exports.DATABAR14_FINDERS = __reexport5.DATABAR14_FINDERS; __exports.dataBar14CharacterWidths = __reexport5.dataBar14CharacterWidths; __exports.dataBar14ValueForWidths = __reexport5.dataBar14ValueForWidths; __exports.dataBarWidths = __reexport5.dataBarWidths;
+
+
+};
+
+__modules["render/options.js"] = function (__require, __exports) {
+/**
+ * Shared render options, normalised once so every backend agrees.
+ *
+ * @module render/options
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+
+/**
+ * @typedef {object} RenderOptions
+ * @property {number} [scale] Pixels per module. Default 8.
+ * @property {number} [margin] Quiet-zone modules on every side. Default 4.
+ * @property {string} [dark] Colour of set modules. Default '#000000'.
+ * @property {string} [light] Colour of clear modules, or 'none' for transparent.
+ * @property {number} [barHeight] For 1D symbols: total bar height in pixels.
+ */
+
+/**
+ * Expand and pad the matrix, and resolve every dimension.
+ *
+ * Linear symbols arrive one module tall. They are stretched to `barHeight`
+ * *before* the quiet zone is applied, so the margin ends up uniform on all
+ * four sides — padding first would leave a quiet zone one module tall against
+ * bars a hundred pixels tall, which no scanner would accept.
+ *
+ * @param {BitMatrix} matrix
+ * @param {RenderOptions} options
+ */
+function normalizeOptions(matrix, options = {}) {
+  const scale = Math.max(1, Math.floor(options.scale ?? 8));
+  const margin = Math.max(0, Math.floor(options.margin ?? 4));
+  const dark = options.dark ?? '#000000';
+  const light = options.light ?? '#ffffff';
+  const barHeight = options.barHeight ?? null;
+
+  let base = matrix;
+  const is1D = matrix.height === 1;
+
+  if (is1D) {
+    // Default to a bar height that stays scannable: tall enough that a laser
+    // crossing at a slight angle still passes through the whole symbol.
+    const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
+    const rows = Math.max(1, Math.round(targetPixels / scale));
+    base = new BitMatrix(matrix.width, rows);
+    for (let x = 0; x < matrix.width; x++) {
+      if (!matrix.get(x, 0)) continue;
+      for (let y = 0; y < rows; y++) base.set(x, y);
+    }
+  }
+
+  const source = margin > 0 ? base.withMargin(margin) : base;
+
+  return {
+    scale,
+    margin,
+    dark,
+    light,
+    is1D,
+    source,
+    rowHeight: scale,
+    pixelWidth: source.width * scale,
+    pixelHeight: source.height * scale,
+  };
+}
+
+/**
+ * Parse a CSS colour into RGBA bytes.
+ *
+ * Supports the forms a barcode actually needs: #rgb, #rgba, #rrggbb,
+ * #rrggbbaa, rgb(), rgba(), plus 'none' and 'transparent'.
+ *
+ * @param {string} colour
+ * @returns {[number, number, number, number]}
+ */
+function parseColor(colour) {
+  const value = String(colour).trim().toLowerCase();
+
+  if (value === 'none' || value === 'transparent') return [0, 0, 0, 0];
+  if (value === 'white') return [255, 255, 255, 255];
+  if (value === 'black') return [0, 0, 0, 255];
+
+  if (value[0] === '#') {
+    const hex = value.slice(1);
+    const expand = (c) => parseInt(c + c, 16);
     if (hex.length === 3) {
       return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 255];
     }
@@ -11513,6 +15866,12 @@ const qr = __require("qr/index.js");
 const aztec = __require("aztec/index.js");
 const pdf417 = __require("pdf417/index.js");
 const micropdf417 = __require("micropdf417/index.js");
+const microqr = __require("microqr/index.js");
+const rmqr = __require("rmqr/index.js");
+const frameqr = __require("frameqr/index.js");
+const aztecRune = __require("aztecrune/index.js");
+const compactPdf417 = __require("compactpdf417/index.js");
+const databar = __require("databar/index.js");
 __exports.BitMatrix = BitMatrix;
 const __reexport0 = __require("core/errors.js"); __exports.BarcodeError = __reexport0.BarcodeError; __exports.EncodeError = __reexport0.EncodeError; __exports.NotFoundError = __reexport0.NotFoundError; __exports.FormatError = __reexport0.FormatError; __exports.ChecksumError = __reexport0.ChecksumError;
 const __reexport1 = __require("image/luminance.js"); __exports.LuminanceSource = __reexport1.LuminanceSource;
@@ -11526,8 +15885,16 @@ const __reexport7 = __require("render/index.js"); __exports.renderToCanvasAutoAs
 const __reexport8 = __require("qr/index.js"); __exports.encodeQR = __reexport8.encodeQR; __exports.decodeQR = __reexport8.decodeQR; __exports.detectQR = __reexport8.detectQR; __exports.detectAndDecodeQR = __reexport8.detectAndDecodeQR;
 const __reexport9 = __require("datamatrix/index.js"); __exports.encodeDataMatrix = __reexport9.encodeDataMatrix; __exports.decodeDataMatrix = __reexport9.decodeDataMatrix; __exports.detectDataMatrix = __reexport9.detectDataMatrix; __exports.detectAndDecodeDataMatrix = __reexport9.detectAndDecodeDataMatrix;
 const __reexport10 = __require("aztec/index.js"); __exports.encodeAztec = __reexport10.encodeAztec; __exports.decodeAztec = __reexport10.decodeAztec; __exports.detectAztec = __reexport10.detectAztec; __exports.detectAndDecodeAztec = __reexport10.detectAndDecodeAztec;
+Object.assign(__exports, __require("aztecrune/index.js"));
 const __reexport11 = __require("pdf417/index.js"); __exports.encodePDF417 = __reexport11.encodePDF417; __exports.decodePDF417 = __reexport11.decodePDF417; __exports.detectPDF417 = __reexport11.detectPDF417; __exports.detectAndDecodePDF417 = __reexport11.detectAndDecodePDF417;
+Object.assign(__exports, __require("compactpdf417/index.js"));
+// DataBar currently exposes verified GS1 data-layer codecs only; physical
+// symbol rendering and image detection remain deliberately out of scope.
+Object.assign(__exports, __require("databar/index.js"));
 const __reexport12 = __require("micropdf417/index.js"); __exports.encodeMicroPDF417 = __reexport12.encodeMicroPDF417; __exports.decodeMicroPDF417 = __reexport12.decodeMicroPDF417; __exports.detectMicroPDF417 = __reexport12.detectMicroPDF417; __exports.detectAndDecodeMicroPDF417 = __reexport12.detectAndDecodeMicroPDF417;
+const __reexport13 = __require("microqr/index.js"); __exports.encodeMicroQR = __reexport13.encodeMicroQR; __exports.decodeMicroQR = __reexport13.decodeMicroQR; __exports.detectMicroQR = __reexport13.detectMicroQR; __exports.detectAndDecodeMicroQR = __reexport13.detectAndDecodeMicroQR;
+const __reexport14 = __require("rmqr/index.js"); __exports.encodeRMQR = __reexport14.encodeRMQR; __exports.decodeRMQR = __reexport14.decodeRMQR; __exports.detectRMQR = __reexport14.detectRMQR; __exports.detectAndDecodeRMQR = __reexport14.detectAndDecodeRMQR;
+const __reexport15 = __require("frameqr/index.js"); __exports.encodeFrameQR = __reexport15.encodeFrameQR; __exports.decodeFrameQR = __reexport15.decodeFrameQR; __exports.detectFrameQR = __reexport15.detectFrameQR; __exports.detectAndDecodeFrameQR = __reexport15.detectAndDecodeFrameQR;
 
 /**
  * @typedef {object} FormatInfo
@@ -11563,6 +15930,17 @@ const pdf417CanEncode = typeof pdf417.encodePDF417 === 'function';
 const pdf417CanDecode = typeof pdf417.detectAndDecodePDF417 === 'function';
 const microPdf417CanEncode = typeof micropdf417.encodeMicroPDF417 === 'function';
 const microPdf417CanDecode = typeof micropdf417.detectAndDecodeMicroPDF417 === 'function';
+const microQrCanEncode = typeof microqr.encodeMicroQR === 'function';
+const microQrCanDecode = typeof microqr.detectAndDecodeMicroQR === 'function';
+const rmqrCanEncode = typeof rmqr.encodeRMQR === 'function';
+const rmqrCanDecode = typeof rmqr.detectAndDecodeRMQR === 'function';
+const frameQrCanEncode = typeof frameqr.encodeFrameQR === 'function';
+const frameQrCanDecode = typeof frameqr.detectAndDecodeFrameQR === 'function';
+const aztecRuneCanEncode = typeof aztecRune.encodeAztecRune === 'function';
+const aztecRuneCanDecode = typeof aztecRune.detectAndDecodeAztecRune === 'function';
+const compactPdf417CanEncode = typeof compactPdf417.encodeCompactPDF417 === 'function';
+const compactPdf417CanDecode = typeof compactPdf417.detectAndDecodeCompactPDF417 === 'function';
+const dataBarCanEncode = typeof databar.encodeDataBar14 === 'function';
 
 /**
  * Every format this build supports.
@@ -11604,6 +15982,13 @@ function listFormats() {
     canRead: aztecCanDecode,
     kind: /** @type {'2D'} */ ('2D'),
   });
+  formats.push({
+    id: 'aztecrune',
+    label: 'Aztec Rune',
+    canWrite: aztecRuneCanEncode,
+    canRead: aztecRuneCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
   formats.push({
     id: 'pdf417',
     label: 'PDF417',
@@ -11611,6 +15996,13 @@ function listFormats() {
     canRead: pdf417CanDecode,
     kind: /** @type {'2D'} */ ('2D'),
   });
+  formats.push({
+    id: 'compactpdf417',
+    label: 'Compact PDF417',
+    canWrite: compactPdf417CanEncode,
+    canRead: compactPdf417CanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
   formats.push({
     id: 'micropdf417',
     label: 'MicroPDF417',
@@ -11618,6 +16010,34 @@ function listFormats() {
     canRead: microPdf417CanDecode,
     kind: /** @type {'2D'} */ ('2D'),
   });
+  formats.push({
+    id: 'microqr',
+    label: 'Micro QR Code',
+    canWrite: microQrCanEncode,
+    canRead: microQrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'rmqr',
+    label: 'rMQR Code',
+    canWrite: rmqrCanEncode,
+    canRead: rmqrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'frameqr',
+    label: 'Sythos Canvas QR profile',
+    canWrite: frameQrCanEncode,
+    canRead: frameQrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'gs1databar14',
+    label: 'GS1 DataBar Omnidirectional / Truncated',
+    canWrite: dataBarCanEncode,
+    canRead: false,
+    kind: /** @type {'1D'} */ ('1D'),
+  });
 
   return formats;
 }
@@ -11648,6 +16068,14 @@ function listFormats() {
  * @param {'auto'|'text'|'byte'|'numeric'} [options.compaction] PDF417 compaction mode.
  * @param {number} [options.eci] MicroPDF417 byte-compaction ECI assignment (3 or 26).
  * @param {number} [options.aspectRatio] Preferred MicroPDF417 symbol aspect ratio.
+ * @param {object} [options.canvas] Sythos Canvas QR artwork reservation.
+ * @param {'square'|'circle'|'diamond'} [options.canvas.shape] Canvas shape.
+ * @param {number} [options.canvas.size] Odd canvas size in QR modules.
+ * @param {number} [options.canvas.width] Canvas width in QR modules.
+ * @param {number} [options.canvas.height] Canvas height in QR modules.
+ * @param {number} [options.canvas.centerX] Canvas centre X in QR modules.
+ * @param {number} [options.canvas.centerY] Canvas centre Y in QR modules.
+ * @param {0|90|180|270} [options.canvas.angle] Canvas quarter-turn.
  * @returns {BitMatrix}
  */
 function encode(text, options = {}) {
@@ -11663,16 +16091,34 @@ function encode(text, options = {}) {
   if (format === 'aztec' || format === 'aztec-code') {
     return aztec.encodeAztec(value, options);
   }
+  if (format === 'aztecrune' || format === 'aztec-rune' || format === 'rune') {
+    return aztecRune.encodeAztecRune(value, options);
+  }
   if (format === 'pdf417' || format === 'pdf-417') {
     return pdf417.encodePDF417(value, options);
   }
+  if (format === 'compactpdf417' || format === 'compact-pdf417' || format === 'compact-pdf-417') {
+    return compactPdf417.encodeCompactPDF417(value, options);
+  }
   if (format === 'micropdf417' || format === 'micro-pdf417' || format === 'micro-pdf-417') {
     return micropdf417.encodeMicroPDF417(value, options);
   }
+  if (format === 'microqr' || format === 'micro-qr') {
+    return microqr.encodeMicroQR(value, options);
+  }
+  if (format === 'rmqr' || format === 'r-mqr' || format === 'rectangular-micro-qr') {
+    return rmqr.encodeRMQR(value, options);
+  }
+  if (format === 'frameqr' || format === 'frame-qr' || format === 'canvas-qr') {
+    return frameqr.encodeFrameQR(value, options);
+  }
+  if (format === 'gs1databar14' || format === 'gs1-databar14' || format === 'databar') {
+    return databar.encodeDataBar14(value, options);
+  }
 
   const entry = ONED_FORMATS[format];
   if (!entry) {
-    const known = [...Object.keys(ONED_FORMATS), 'qr', 'datamatrix', 'aztec', 'pdf417', 'micropdf417'].join(', ');
+    const known = [...Object.keys(ONED_FORMATS), 'qr', 'datamatrix', 'aztec', 'aztecrune', 'pdf417', 'compactpdf417', 'micropdf417', 'microqr', 'rmqr', 'frameqr', 'gs1databar14'].join(', ');
     throw new EncodeError(`Unknown format "${format}". Known formats: ${known}`);
   }
   return entry.encode(value, options);
@@ -11695,6 +16141,9 @@ function encode(text, options = {}) {
  * @property {number} [rowHeight] PDF417 row height in modules.
  * @property {number} [variant] MicroPDF417 predefined variant number.
  * @property {number} [eccCodewords] MicroPDF417 fixed error-correction codewords.
+ * @property {string} [profile] Sythos Canvas QR profile identifier.
+ * @property {boolean} [certified] Whether the profile is certified by its originator.
+ * @property {object} [canvas] Canvas reservation metadata for the Sythos profile.
  */
 
 /**
@@ -11709,6 +16158,8 @@ function encode(text, options = {}) {
  * @param {string[]} [options.formats] Restrict to these format ids.
  * @param {boolean} [options.tryHarder] Retry inverted and rotated. Default true.
  * @param {'global'|'hybrid'|'auto'} [options.binarizer]
+ * @param {object} [options.frameqr] Sythos Canvas QR detector options when
+ *   the profile marker is not preserved through image rendering.
  * @returns {DecodeResult[]}
  */
 function decode(image, options = {}) {
@@ -11717,8 +16168,13 @@ function decode(image, options = {}) {
   const wantQR = !want || want.has('qr') || want.has('qrcode');
   const wantDataMatrix = !want || want.has('datamatrix') || want.has('data-matrix');
   const wantAztec = !want || want.has('aztec') || want.has('aztec-code');
+  const wantAztecRune = !want || want.has('aztecrune') || want.has('aztec-rune') || want.has('rune');
   const wantPDF417 = !want || want.has('pdf417') || want.has('pdf-417');
+  const wantCompactPDF417 = !want || want.has('compactpdf417') || want.has('compact-pdf417') || want.has('compact-pdf-417');
   const wantMicroPDF417 = !want || want.has('micropdf417') || want.has('micro-pdf417') || want.has('micro-pdf-417');
+  const wantMicroQR = !want || want.has('microqr') || want.has('micro-qr');
+  const wantRMQR = !want || want.has('rmqr') || want.has('r-mqr') || want.has('rectangular-micro-qr');
+  const wantFrameQR = !want || want.has('frameqr') || want.has('frame-qr') || want.has('canvas-qr');
   const wantOneD = !want || [...want].some((f) => f in ONED_FORMATS);
 
   const source = LuminanceSource.fromImageData(image);
@@ -11771,6 +16227,15 @@ function decode(image, options = {}) {
       }
     }
 
+    if (wantAztecRune && aztecRuneCanDecode) {
+      try {
+        const found = aztecRune.detectAndDecodeAztecRune(bits);
+        if (found) results.push({ ...found, format: 'aztecrune' });
+      } catch {
+        /* no Aztec Rune in this pass */
+      }
+    }
+
     if (wantPDF417 && pdf417CanDecode) {
       try {
         const found = pdf417.detectAndDecodePDF417(bits);
@@ -11780,6 +16245,15 @@ function decode(image, options = {}) {
       }
     }
 
+    if (wantCompactPDF417 && compactPdf417CanDecode) {
+      try {
+        const found = compactPdf417.detectAndDecodeCompactPDF417(bits);
+        if (found) results.push({ ...found, format: 'compactpdf417' });
+      } catch {
+        /* no Compact PDF417 in this pass */
+      }
+    }
+
     if (wantMicroPDF417 && microPdf417CanDecode) {
       // MicroPDF417 detection measures runs across the whole raster. Hybrid
       // thresholding can alter uniform modules near local-window boundaries,
@@ -11795,6 +16269,35 @@ function decode(image, options = {}) {
       }
     }
 
+    if (wantMicroQR && microQrCanDecode) {
+      try {
+        for (const found of microqr.detectAndDecodeMicroQR(bits)) {
+          results.push({ ...found, format: 'microqr' });
+        }
+      } catch {
+        /* no Micro QR in this pass */
+      }
+    }
+
+    if (wantRMQR && rmqrCanDecode) {
+      try {
+        const found = rmqr.detectAndDecodeRMQR(bits);
+        if (found) results.push({ ...found, format: 'rmqr' });
+      } catch {
+        /* no rMQR in this pass */
+      }
+    }
+
+    if (wantFrameQR && frameQrCanDecode) {
+      try {
+        for (const found of frameqr.detectAndDecodeFrameQR(bits, options.frameqr ?? {})) {
+          results.push({ ...found, format: 'frameqr' });
+        }
+      } catch {
+        /* no Sythos Canvas QR profile in this pass */
+      }
+    }
+
     if (wantOneD) {
       const oneDFormats = want ? [...want].filter((f) => f in ONED_FORMATS) : null;
       for (const found of decodeOneD(bits, { formats: oneDFormats, tryHarder })) {
@@ -11829,7 +16332,7 @@ function decodeStrict(image, options) {
 }
 
 /** Library version, matching package.json. */
-const VERSION = '1.2.5';
+const VERSION = '1.4.1';
 
 __exports.listFormats = listFormats;
 __exports.encode = encode;