qr 0.5.2 → 0.5.4

package/index.js

@@ -50,32 +50,32 @@ function mod(a, b) {
 function fillArr(length, val) {
     return new Array(length).fill(val);
 }
+function popcnt(n) {
+    n = n - ((n >>> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+    return (((n + (n >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
 /**
  * Interleaves byte blocks.
  * @param blocks [[1, 2, 3], [4, 5, 6]]
  * @returns [1, 4, 2, 5, 3, 6]
  */
-function interleaveBytes(...blocks) {
-    let len = 0;
-    for (const b of blocks)
-        len = Math.max(len, b.length);
-    const res = [];
-    for (let i = 0; i < len; i++) {
-        for (const b of blocks) {
-            if (i >= b.length)
-                continue; // outside of block, skip
-            res.push(b[i]);
+function interleaveBytes(blocks) {
+    let maxLen = 0;
+    let totalLen = 0;
+    for (const block of blocks) {
+        maxLen = Math.max(maxLen, block.length);
+        totalLen += block.length;
+    }
+    const result = new Uint8Array(totalLen);
+    let idx = 0;
+    for (let i = 0; i < maxLen; i++) {
+        for (const block of blocks) {
+            if (i < block.length)
+                result[idx++] = block[i];
         }
     }
-    return new Uint8Array(res);
-}
-function includesAt(lst, pattern, index) {
-    if (index < 0 || index + pattern.length > lst.length)
-        return false;
-    for (let i = 0; i < pattern.length; i++)
-        if (pattern[i] !== lst[index + i])
-            return false;
-    return true;
+    return result;
 }
 // Optimize for minimal score/penalty
 function best() {
@@ -120,6 +120,39 @@ function alphabet(alphabet) {
         },
     };
 }
+// Transpose 32x32 bit matrix in-place
+// a[0..31] are 32 rows of 32 bits each; after transpose they become 32 columns.
+function transpose32(a) {
+    if (a.length !== 32)
+        throw new Error('expects 32 element matrix');
+    const masks = [0x55555555, 0x33333333, 0x0f0f0f0f, 0x00ff00ff, 0x0000ffff];
+    // Hello again, FFT
+    for (let stage = 0; stage < 5; stage++) {
+        const m = masks[stage] >>> 0;
+        const s = 1 << stage; // 1,2,4,8,16
+        const step = s << 1; // 2,4,8,16,32
+        for (let i = 0; i < 32; i += step) {
+            for (let k = 0; k < s; k++) {
+                const i0 = i + k;
+                const i1 = i0 + s;
+                const x = a[i0] >>> 0;
+                const y = a[i1] >>> 0;
+                const t = ((x >>> s) ^ y) & m;
+                a[i0] = (x ^ (t << s)) >>> 0;
+                a[i1] = (y ^ t) >>> 0;
+            }
+        }
+    }
+}
+const bitMask = (x) => (1 << (x & 31)) >>> 0;
+const rangeMask = (shift, len) => {
+    // len in [0..32], shift in [0..31]
+    if (len === 0)
+        return 0;
+    if (len === 32)
+        return 0xffffffff;
+    return (((1 << len) - 1) << shift) >>> 0;
+};
 export class Bitmap {
     static size(size, limit) {
         if (typeof size === 'number')
@@ -142,8 +175,8 @@ export class Bitmap {
         s = s.replace(/^\n+/g, '').replace(/\n+$/g, '');
         const lines = s.split(String.fromCharCode(chCodes.newline));
         const height = lines.length;
-        const data = new Array(height);
         let width;
+        const rows = [];
         for (const line of lines) {
             const row = line.split('').map((i) => {
                 if (i === 'X')
@@ -154,26 +187,50 @@ export class Bitmap {
                     return undefined;
                 throw new Error(`Bitmap.fromString: unknown symbol=${i}`);
             });
-            if (width && row.length !== width)
+            if (width !== undefined && row.length !== width)
                 throw new Error(`Bitmap.fromString different row sizes: width=${width} cur=${row.length}`);
             width = row.length;
-            data.push(row);
+            rows.push(row);
         }
-        if (!width)
+        if (width === undefined)
             width = 0;
-        return new Bitmap({ height, width }, data);
+        return new Bitmap({ height, width }, rows);
     }
-    data;
+    // Two bitsets:
+    // defined=0 -> undefined
+    // defined=1,value=0 -> false
+    // defined=1,value=1 -> true
+    defined;
+    value;
+    tailMask;
+    words;
+    fullWords;
     height;
     width;
     constructor(size, data) {
         const { height, width } = Bitmap.size(size);
-        this.data = data || Array.from({ length: height }, () => fillArr(width, undefined));
         this.height = height;
         this.width = width;
+        this.tailMask = rangeMask(0, width & 31 || 32);
+        this.words = Math.ceil(width / 32) | 0;
+        this.fullWords = Math.floor(width / 32) | 0;
+        this.value = new Uint32Array(this.words * height);
+        this.defined = new Uint32Array(this.value.length);
+        if (data) {
+            // accept same semantics as old version
+            if (data.length !== height)
+                throw new Error(`Bitmap: data height mismatch: exp=${height} got=${data.length}`);
+            for (let y = 0; y < height; y++) {
+                const row = data[y];
+                if (!row || row.length !== width)
+                    throw new Error(`Bitmap: data width mismatch at y=${y}: exp=${width} got=${row?.length}`);
+                for (let x = 0; x < width; x++)
+                    this.set(x, y, row[x]);
+            }
+        }
     }
     point(p) {
-        return this.data[p.y][p.x];
+        return this.get(p.x, p.y);
     }
     isInside(p) {
         return 0 <= p.x && p.x < this.width && 0 <= p.y && p.y < this.height;
@@ -196,27 +253,111 @@ export class Bitmap {
         c.y = mod(c.y, this.height);
         return c;
     }
+    /**
+     * Return pixel bit index
+     */
+    wordIndex(x, y) {
+        return y * this.words + (x >>> 5);
+    }
+    bitIndex(x, y) {
+        return { word: this.wordIndex(x, y), bit: x & 31 };
+    }
+    isDefined(x, y) {
+        const wi = this.wordIndex(x, y);
+        const m = bitMask(x);
+        return (this.defined[wi] & m) !== 0;
+    }
+    get(x, y) {
+        const wi = this.wordIndex(x, y);
+        const m = bitMask(x);
+        return (this.value[wi] & m) !== 0;
+    }
+    maskWord(wi, mask, v) {
+        const { defined, value } = this;
+        defined[wi] |= mask;
+        value[wi] = (value[wi] & ~mask) | (-v & mask);
+    }
+    set(x, y, v) {
+        if (v === undefined)
+            return;
+        this.maskWord(this.wordIndex(x, y), bitMask(x), v);
+    }
+    // word-span fill for constant values (fast path)
+    fillRectConst(x0, y0, w, h, v) {
+        if (w <= 0 || h <= 0)
+            return;
+        if (v === undefined)
+            return;
+        const { value, defined, words } = this;
+        const startWord = x0 >>> 5;
+        const endWord = (x0 + w - 1) >>> 5;
+        const startBit = x0 & 31;
+        const endBit = (x0 + w - 1) & 31;
+        for (let ry = 0; ry < h; ry++) {
+            const rowBase = (y0 + ry) * words;
+            if (startWord === endWord) {
+                const mask = rangeMask(startBit, endBit - startBit + 1);
+                this.maskWord(rowBase + startWord, mask, v);
+                continue;
+            }
+            this.maskWord(rowBase + startWord, rangeMask(startBit, 32 - startBit), v);
+            for (let i = startWord + 1; i < endWord; i++) {
+                defined[rowBase + i] = 0xffffffff;
+                value[rowBase + i] = v ? 0xffffffff : 0;
+            }
+            this.maskWord(rowBase + endWord, rangeMask(0, endBit + 1), v);
+        }
+    }
+    rectWords(x, y, width, height, cb) {
+        for (let yPos = 0; yPos < height; yPos++) {
+            const Py = y + yPos;
+            for (let xPos = 0; xPos < width;) {
+                const bitX = x + xPos;
+                const { bit, word } = this.bitIndex(bitX, Py);
+                const bitsPerWord = Math.min(32 - bit, width - xPos);
+                cb(word, bitX, xPos, yPos, bitsPerWord);
+                xPos += bitsPerWord;
+            }
+        }
+    }
     // Basically every operation can be represented as rect
-    rect(c, size, value) {
+    rect(c, size, fn) {
         const { x, y } = this.xy(c);
         const { height, width } = Bitmap.size(size, this.size({ x, y }));
-        for (let yPos = 0; yPos < height; yPos++) {
-            for (let xPos = 0; xPos < width; xPos++) {
-                // NOTE: we use give function relative coordinates inside box
-                this.data[y + yPos][x + xPos] =
-                    typeof value === 'function'
-                        ? value({ x: xPos, y: yPos }, this.data[y + yPos][x + xPos])
-                        : value;
-            }
+        if (typeof fn !== 'function') {
+            this.fillRectConst(x, y, width, height, fn);
+            return this;
         }
+        const { defined, value } = this;
+        this.rectWords(x, y, width, height, (wi, bitX, xPos, yPos, n) => {
+            let defWord = 0;
+            let valWord = value[wi];
+            for (let b = 0; b < n; b++) {
+                const mask = bitMask(bitX + b);
+                const res = fn({ x: xPos + b, y: yPos }, (valWord & mask) !== 0);
+                if (res === undefined)
+                    continue;
+                defWord |= mask;
+                valWord = (valWord & ~mask) | (-res & mask);
+            }
+            defined[wi] |= defWord;
+            value[wi] = valWord;
+        });
         return this;
     }
     // returns rectangular part of bitmap
     rectRead(c, size, fn) {
-        return this.rect(c, size, (c, cur) => {
-            fn(c, cur);
-            return cur;
+        const { x, y } = this.xy(c);
+        const { height, width } = Bitmap.size(size, this.size({ x, y }));
+        const { value } = this;
+        this.rectWords(x, y, width, height, (wi, bitX, xPos, yPos, n) => {
+            const valWord = value[wi];
+            for (let b = 0; b < n; b++) {
+                const mask = bitMask(bitX + b);
+                fn({ x: xPos + b, y: yPos }, (valWord & mask) !== 0);
+            }
         });
+        return this;
     }
     // Horizontal & vertical lines
     hLine(c, len, value) {
@@ -229,25 +370,93 @@ export class Bitmap {
     border(border = 2, value) {
         const height = this.height + 2 * border;
         const width = this.width + 2 * border;
-        const v = fillArr(border, value);
-        const h = Array.from({ length: border }, () => fillArr(width, value));
-        return new Bitmap({ height, width }, [...h, ...this.data.map((i) => [...v, ...i, ...v]), ...h]);
+        const out = new Bitmap({ height, width });
+        // fill everything with border value, then embed original
+        out.rect(0, Infinity, value);
+        out.embed({ x: border, y: border }, this);
+        return out;
     }
     // Embed another bitmap on coordinates
-    embed(c, bm) {
-        return this.rect(c, bm.size(), ({ x, y }) => bm.data[y][x]);
+    embed(c, src) {
+        const { x, y } = this.xy(c);
+        const { height, width } = Bitmap.size(src.size(), this.size({ x, y }));
+        if (width <= 0 || height <= 0)
+            return this;
+        const { value, defined } = this;
+        const { words: srcStride, value: srcValue } = src;
+        for (let yPos = 0; yPos < height; yPos++) {
+            const srcRow = yPos * srcStride;
+            for (let xPos = 0; xPos < width;) {
+                const dstX = x + xPos;
+                const { word: dstWord, bit: dstBit } = this.bitIndex(dstX, y + yPos);
+                const { word: srcWord, bit: srcBit } = src.bitIndex(xPos, yPos);
+                const len = Math.min(32 - dstBit, width - xPos);
+                const w0 = srcValue[srcWord];
+                const w1 = srcBit && srcWord + 1 < srcRow + srcStride ? srcValue[srcWord + 1] : 0;
+                const sVal = srcBit ? ((w0 >>> srcBit) | (w1 << (32 - srcBit))) >>> 0 : w0;
+                const dstMask = rangeMask(dstBit, len);
+                const valBits = ((sVal & rangeMask(0, len)) << dstBit) >>> 0;
+                defined[dstWord] |= dstMask;
+                value[dstWord] = (value[dstWord] & ~dstMask) | valBits;
+                xPos += len;
+            }
+        }
+        return this;
     }
     // returns rectangular part of bitmap
     rectSlice(c, size = this.size()) {
-        const rect = new Bitmap(Bitmap.size(size, this.size(this.xy(c))));
-        this.rect(c, size, ({ x, y }, cur) => (rect.data[y][x] = cur));
+        const { x, y } = this.xy(c);
+        const { height, width } = Bitmap.size(size, this.size({ x, y }));
+        const rect = new Bitmap({ height, width });
+        this.rectRead({ x, y }, { height, width }, (p, cur) => {
+            if (this.isDefined(x + p.x, y + p.y)) {
+                rect.set(p.x, p.y, cur);
+            }
+        });
         return rect;
     }
     // Change shape, replace rows with columns (data[y][x] -> data[x][y])
-    inverse() {
-        const { height, width } = this;
-        const res = new Bitmap({ height: width, width: height });
-        return res.rect({ x: 0, y: 0 }, Infinity, ({ x, y }) => this.data[x][y]);
+    transpose() {
+        const { height, width, value, defined, words } = this;
+        const dst = new Bitmap({ height: width, width: height });
+        const { words: dstStride, value: dstValue, defined: dstDefined, tailMask: dstTail } = dst;
+        const tmpV = new Uint32Array(32);
+        const tmpD = new Uint32Array(32);
+        // Process src in blocks: y in [by..by+31], x in 32-bit words
+        for (let by = 0; by < height; by += 32) {
+            for (let bx = 0; bx < words; bx++) {
+                const rows = Math.min(32, height - by);
+                for (let r = 0; r < rows; r++) {
+                    const wi = this.wordIndex(32 * bx, by + r);
+                    tmpV[r] = value[wi];
+                    tmpD[r] = defined[wi];
+                }
+                // zero-pad remainder
+                tmpV.fill(0, rows);
+                tmpD.fill(0, rows);
+                transpose32(tmpV);
+                transpose32(tmpD);
+                for (let i = 0; i < 32; i++) {
+                    const dstY = bx * 32 + i;
+                    if (dstY >= width)
+                        break;
+                    const dstPos = dst.wordIndex(by, dstY);
+                    const curMask = by >>> 5 === dstStride - 1 ? dstTail : 0xffffffff;
+                    dstValue[dstPos] = tmpV[i] & curMask;
+                    dstDefined[dstPos] = tmpD[i] & curMask;
+                }
+            }
+        }
+        return dst;
+    }
+    // black <-> white (inplace)
+    negate() {
+        const n = this.defined.length;
+        for (let i = 0; i < n; i++) {
+            this.value[i] = ~this.value[i];
+            this.defined[i] = 0xffffffff;
+        }
+        return this;
     }
     // Each pixel size is multiplied by factor
     scale(factor) {
@@ -255,34 +464,150 @@ export class Bitmap {
             throw new Error(`invalid scale factor: ${factor}`);
         const { height, width } = this;
         const res = new Bitmap({ height: factor * height, width: factor * width });
-        return res.rect({ x: 0, y: 0 }, Infinity, ({ x, y }) => this.data[Math.floor(y / factor)][Math.floor(x / factor)]);
+        return res.rect({ x: 0, y: 0 }, Infinity, ({ x, y }) => this.get((x / factor) | 0, (y / factor) | 0));
     }
     clone() {
         const res = new Bitmap(this.size());
-        return res.rect({ x: 0, y: 0 }, this.size(), ({ x, y }) => this.data[y][x]);
+        res.defined.set(this.defined);
+        res.value.set(this.value);
+        return res;
     }
     // Ensure that there is no undefined values left
     assertDrawn() {
-        this.rectRead(0, Infinity, (_, cur) => {
-            if (typeof cur !== 'boolean')
-                throw new Error(`Invalid color type=${typeof cur}`);
-        });
+        const { height, width, defined, tailMask, fullWords, words } = this;
+        if (!height || !width)
+            return;
+        for (let y = 0; y < height; y++) {
+            const rowBase = y * words;
+            for (let wi = 0; wi < fullWords; wi++) {
+                if (defined[rowBase + wi] !== 0xffffffff)
+                    throw new Error(`Invalid color type=undefined`);
+            }
+            if (words !== fullWords && (defined[rowBase + fullWords] & tailMask) !== tailMask)
+                throw new Error(`Invalid color type=undefined`);
+        }
     }
-    // Simple string representation for debugging
+    countPatternInRow(y, patternLen, ...patterns) {
+        if (patternLen <= 0 || patternLen >= 32)
+            throw new Error('wrong patternLen');
+        const mask = (1 << patternLen) - 1;
+        const { width, value, words } = this;
+        let count = 0;
+        const rowBase = this.wordIndex(0, y);
+        for (let i = 0, window = 0; i < words; i++) {
+            const w = value[rowBase + i];
+            const bitEnd = i === words - 1 ? width & 31 || 32 : 32;
+            for (let b = 0; b < bitEnd; b++) {
+                window = ((window << 1) | ((w >>> b) & 1)) & mask;
+                if (i * 32 + b + 1 < patternLen)
+                    continue;
+                for (const p of patterns) {
+                    if (window !== p)
+                        continue;
+                    count++;
+                    break;
+                }
+            }
+        }
+        return count;
+    }
+    getRuns(y, fn) {
+        const { width, value, words } = this;
+        if (width === 0)
+            return;
+        let runLen = 0;
+        let runValue;
+        const rowBase = this.wordIndex(0, y);
+        for (let i = 0; i < words; i++) {
+            const word = value[rowBase + i];
+            const bitEnd = i === words - 1 ? width & 31 || 32 : 32;
+            for (let b = 0; b < bitEnd; b++) {
+                const bit = (word & (1 << b)) !== 0;
+                if (bit === runValue) {
+                    runLen++;
+                    continue;
+                }
+                if (runValue !== undefined)
+                    fn(runLen, runValue);
+                runValue = bit;
+                runLen = 1;
+            }
+        }
+        if (runValue !== undefined)
+            fn(runLen, runValue);
+    }
+    popcnt() {
+        const { height, width, words, fullWords, tailMask } = this;
+        if (!height || !width)
+            return 0;
+        let count = 0;
+        for (let y = 0; y < height; y++) {
+            const rowBase = y * words;
+            for (let wi = 0; wi < fullWords; wi++)
+                count += popcnt(this.value[rowBase + wi]);
+            if (words !== fullWords)
+                count += popcnt(this.value[rowBase + fullWords] & tailMask);
+        }
+        return count;
+    }
+    countBoxes2x2(y) {
+        const { width, words } = this;
+        if (width < 2 || (y | 0) < 0 || y + 1 >= this.height)
+            return 0;
+        const base0 = this.wordIndex(0, y) | 0;
+        const base1 = this.wordIndex(0, y + 1) | 0;
+        // valid "left-edge" positions x in [0 .. W-2]
+        const tailBits = width & 31;
+        const validLast = tailBits === 0 ? 0x7fffffff : rangeMask(0, (width - 1) & 31);
+        let boxes = 0;
+        for (let wi = 0; wi < words; wi++) {
+            const a0 = this.value[base0 + wi];
+            const a1 = this.value[base1 + wi];
+            // Compare bit x with bit x+1 at same bit position.
+            const eqV = ~(a0 ^ a1) >>> 0; // row0[x] == row1[x]
+            const n0 = wi + 1 < words ? this.value[base0 + wi + 1] >>> 0 : 0;
+            const eqH0 = ~(a0 ^ (((a0 >>> 1) | ((n0 & 1) << 31)) >>> 0)) >>> 0; // row0[x] == row0[x+1]
+            const n1 = wi + 1 < words ? this.value[base1 + wi + 1] >>> 0 : 0;
+            const eqH1 = ~(a1 ^ (((a1 >>> 1) | ((n1 & 1) << 31)) >>> 0)) >>> 0; // row1[x] == row1[x+1]
+            let m = (eqV & eqH0 & eqH1) >>> 0;
+            if (wi === words - 1)
+                m &= validLast;
+            boxes += popcnt(m);
+        }
+        return boxes;
+    }
+    // Export
     toString() {
-        return this.data
-            .map((i) => i.map((j) => (j === undefined ? '?' : j ? 'X' : ' ')).join(''))
-            .join(String.fromCharCode(chCodes.newline));
+        const nl = String.fromCharCode(chCodes.newline);
+        let out = '';
+        for (let y = 0; y < this.height; y++) {
+            let line = '';
+            for (let x = 0; x < this.width; x++) {
+                const v = this.get(x, y);
+                line += !this.isDefined(x, y) ? '?' : v ? 'X' : ' ';
+            }
+            out += line + (y + 1 === this.height ? '' : nl);
+        }
+        return out;
+    }
+    toRaw() {
+        const out = Array.from({ length: this.height }, () => new Array(this.width));
+        for (let y = 0; y < this.height; y++) {
+            const row = out[y];
+            for (let x = 0; x < this.width; x++)
+                row[x] = this.get(x, y);
+        }
+        return out;
     }
     toASCII() {
-        const { height, width, data } = this;
+        const { height, width } = this;
         let out = '';
         // Terminal character height is x2 of character width, so we process two rows of bitmap
         // to produce one row of ASCII
         for (let y = 0; y < height; y += 2) {
             for (let x = 0; x < width; x++) {
-                const first = data[y][x];
-                const second = y + 1 >= height ? true : data[y + 1][x]; // if last row outside bitmap, make it black
+                const first = this.get(x, y);
+                const second = y + 1 >= height ? true : this.get(x, y + 1); // if last row outside bitmap, make it black
                 if (!first && !second)
                     out += '█'; // both rows white (empty)
                 else if (!first && second)
@@ -301,9 +626,16 @@ export class Bitmap {
         const reset = cc + '[0m';
         const whiteBG = cc + '[1;47m  ' + reset;
         const darkBG = cc + `[40m  ` + reset;
-        return this.data
-            .map((i) => i.map((j) => (j ? darkBG : whiteBG)).join(''))
-            .join(String.fromCharCode(chCodes.newline));
+        const nl = String.fromCharCode(chCodes.newline);
+        let out = '';
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                const v = this.get(x, y); // undefined -> white
+                out += v ? darkBG : whiteBG;
+            }
+            out += nl;
+        }
+        return out;
     }
     toSVG(optimize = true) {
         let out = `<svg viewBox="0 0 ${this.width} ${this.height}" xmlns="http://www.w3.org/2000/svg">`;
@@ -372,7 +704,7 @@ export class Bitmap {
         let i = 0;
         for (let y = 0; y < height; y++) {
             for (let x = 0; x < width; x++) {
-                const value = !!this.data[y][x] ? 0 : 255;
+                const value = this.get(x, y) ? 0 : 255; // undefined -> white
                 data[i++] = value;
                 data[i++] = value;
                 data[i++] = value;
@@ -740,8 +1072,8 @@ function interleave(ver, ecc) {
                 eccBlocks.push(rs.encode(bytes.subarray(0, len)));
                 bytes = bytes.subarray(len);
             }
-            const resBlocks = interleaveBytes(...blocks);
-            const resECC = interleaveBytes(...eccBlocks);
+            const resBlocks = interleaveBytes(blocks);
+            const resECC = interleaveBytes(eccBlocks);
             const res = new Uint8Array(resBlocks.length + resECC.length);
             res.set(resBlocks);
             res.set(resECC, resBlocks.length);
@@ -798,36 +1130,36 @@ function drawTemplate(ver, ecc, maskIdx, test = false) {
     const alignPos = info.alignmentPatterns(ver);
     for (const y of alignPos) {
         for (const x of alignPos) {
-            if (b.data[y][x] !== undefined)
+            if (b.isDefined(x, y))
                 continue;
             b.embed({ x: x - 2, y: y - 2 }, align); // center of pattern should be at position
         }
     }
     // Timing patterns
     b = b
-        .hLine({ x: 0, y: 6 }, Infinity, ({ x }, cur) => (cur === undefined ? x % 2 == 0 : cur))
-        .vLine({ x: 6, y: 0 }, Infinity, ({ y }, cur) => (cur === undefined ? y % 2 == 0 : cur));
+        .hLine({ x: 0, y: 6 }, Infinity, ({ x }) => (b.isDefined(x, 6) ? undefined : x % 2 == 0))
+        .vLine({ x: 6, y: 0 }, Infinity, ({ y }) => (b.isDefined(6, y) ? undefined : y % 2 == 0));
     // Format information
     {
         const bits = info.formatBits(ecc, maskIdx);
         const getBit = (i) => !test && ((bits >> i) & 1) == 1;
         // vertical
         for (let i = 0; i < 6; i++)
-            b.data[i][8] = getBit(i); // right of top-left finder
+            b.set(8, i, getBit(i)); // right of top-left finder
         // TODO: re-write as lines, like:
         // b.vLine({ x: 8, y: 0 }, 6, ({ x, y }) => getBit(y));
         for (let i = 6; i < 8; i++)
-            b.data[i + 1][8] = getBit(i); // after timing pattern
+            b.set(8, i + 1, getBit(i)); // after timing pattern
         for (let i = 8; i < 15; i++)
-            b.data[size - 15 + i][8] = getBit(i); // right of bottom-left finder
+            b.set(8, size - 15 + i, getBit(i)); // right of bottom-left finder
         // horizontal
         for (let i = 0; i < 8; i++)
-            b.data[8][size - i - 1] = getBit(i); // under top-right finder
+            b.set(size - i - 1, 8, getBit(i)); // under top-right finder
         for (let i = 8; i < 9; i++)
-            b.data[8][15 - i - 1 + 1] = getBit(i); // VVV, after timing
+            b.set(15 - i - 1 + 1, 8, getBit(i)); // VVV, after timing
         for (let i = 9; i < 15; i++)
-            b.data[8][15 - i - 1] = getBit(i); // under top-left finder
-        b.data[size - 8][8] = !test; // bottom-left finder, right
+            b.set(15 - i - 1, 8, getBit(i)); // under top-left finder
+        b.set(8, size - 8, !test); // bottom-left finder, right
     }
     // Version information
     if (ver >= 7) {
@@ -837,8 +1169,8 @@ function drawTemplate(ver, ecc, maskIdx, test = false) {
             const x = Math.floor(i / 3);
             const y = (i % 3) + size - 8 - 3;
             // two copies
-            b.data[x][y] = bit;
-            b.data[y][x] = bit;
+            b.set(y, x, bit);
+            b.set(x, y, bit);
         }
     }
     return b;
@@ -857,7 +1189,7 @@ function zigzag(tpl, maskIdx, fn) {
         for (;; y += dir) {
             for (let j = 0; j < 2; j += 1) {
                 const x = xOffset - j;
-                if (tpl.data[y][x] !== undefined)
+                if (tpl.isDefined(x, y))
                     continue; // skip already written elements
                 fn(x, y, pattern(x, y));
             }
@@ -888,7 +1220,7 @@ export function utf8ToBytes(str) {
         throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
-function encode(ver, ecc, data, type) {
+function encode(ver, ecc, data, type, encoder = utf8ToBytes) {
     let encoded = '';
     let dataLen = data.length;
     if (type === 'numeric') {
@@ -912,7 +1244,7 @@ function encode(ver, ecc, data, type) {
             encoded += bin(t[n - 1], 6); // pad if odd number of chars
     }
     else if (type === 'byte') {
-        const utf8 = utf8ToBytes(data);
+        const utf8 = encoder(data);
         dataLen = utf8.length;
         encoded = Array.from(utf8)
             .map((i) => bin(i, 8))
@@ -950,73 +1282,57 @@ function drawQR(ver, ecc, data, maskIdx, test = false) {
             value = ((data[i >>> 3] >> ((7 - i) & 7)) & 1) !== 0;
             i++;
         }
-        b.data[y][x] = value !== mask; // !== as xor
+        b.set(x, y, value !== mask); // !== as xor
     });
     if (i !== need)
         throw new Error('QR: bytes left after draw');
     return b;
 }
+const mkPattern = (pattern) => {
+    const s = pattern.map((i) => (i ? '1' : '0')).join('');
+    return { len: s.length, n: Number(`0b${s}`) };
+};
+// 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column, preceded or followed by light area 4 modules wide
+const finderPattern = [true, false, true, true, true, false, true]; // dark:light:dark:light:dark
+const lightPattern = [false, false, false, false]; // light area 4 modules wide
+const P1 = mkPattern([...finderPattern, ...lightPattern]);
+const P2 = mkPattern([...lightPattern, ...finderPattern]);
 function penalty(bm) {
-    const inverse = bm.inverse();
+    const { width, height } = bm;
+    const transposed = bm.transpose();
     // Adjacent modules in row/column in same | No. of modules = (5 + i) color
-    const sameColor = (row) => {
-        let res = 0;
-        for (let i = 0, same = 1, last = undefined; i < row.length; i++) {
-            if (last === row[i]) {
-                same++;
-                if (i !== row.length - 1)
-                    continue; // handle last element
-            }
-            if (same >= 5)
-                res += 3 + (same - 5);
-            last = row[i];
-            same = 1;
-        }
-        return res;
-    };
     let adjacent = 0;
-    bm.data.forEach((row) => (adjacent += sameColor(row)));
-    inverse.data.forEach((column) => (adjacent += sameColor(column)));
+    for (let y = 0; y < height; y++) {
+        bm.getRuns(y, (len) => {
+            if (len >= 5)
+                adjacent += 3 + (len - 5);
+        });
+    }
+    for (let y = 0; y < width; y++) {
+        transposed.getRuns(y, (len) => {
+            if (len >= 5)
+                adjacent += 3 + (len - 5);
+        });
+    }
     // Block of modules in same color (Block size = 2x2)
     let box = 0;
-    let b = bm.data;
-    const lastW = bm.width - 1;
-    const lastH = bm.height - 1;
-    for (let x = 0; x < lastW; x++) {
-        for (let y = 0; y < lastH; y++) {
-            const x1 = x + 1;
-            const y1 = y + 1;
-            if (b[x][y] === b[x1][y] && b[x1][y] === b[x][y1] && b[x1][y] === b[x1][y1]) {
-                box += 3;
-            }
-        }
-    }
-    // 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column, preceded or followed by light area 4 modules wide
-    const finderPattern = (row) => {
-        const finderPattern = [true, false, true, true, true, false, true]; // dark:light:dark:light:dark
-        const lightPattern = [false, false, false, false]; // light area 4 modules wide
-        const p1 = [...finderPattern, ...lightPattern];
-        const p2 = [...lightPattern, ...finderPattern];
-        let res = 0;
-        for (let i = 0; i < row.length; i++) {
-            if (includesAt(row, p1, i))
-                res += 40;
-            if (includesAt(row, p2, i))
-                res += 40;
-        }
-        return res;
-    };
+    for (let y = 0; y < height - 1; y++)
+        box += 3 * bm.countBoxes2x2(y);
     let finder = 0;
-    for (const row of bm.data)
-        finder += finderPattern(row);
-    for (const column of inverse.data)
-        finder += finderPattern(column);
+    for (let y = 0; y < height; y++)
+        finder += 40 * bm.countPatternInRow(y, P1.len, P1.n, P2.n);
+    for (let y = 0; y < width; y++)
+        finder += 40 * transposed.countPatternInRow(y, P1.len, P1.n, P2.n);
     // Proportion of dark modules in entire symbol
     // Add 10 points to a deviation of 5% increment or decrement in the proportion
     // ratio of dark module from the referential 50%
     let darkPixels = 0;
-    bm.rectRead(0, Infinity, (_c, val) => (darkPixels += val ? 1 : 0));
-    const darkPercent = (darkPixels / (bm.height * bm.width)) * 100;
+    darkPixels = bm.popcnt();
+    //bm.rectRead(0, Infinity, (_c, val) => (darkPixels += val ? 1 : 0));
+    // for (let y = 0; y < height; y++) {
+    //   for (let x = 0; x < width; x++) if (bm.get(x, y)) darkPixels++;
+    // }
+    const darkPercent = (darkPixels / (height * width)) * 100;
     const dark = 10 * Math.floor(Math.abs(darkPercent - 50) / 5);
     return adjacent + box + finder + dark;
 }
@@ -1057,14 +1373,14 @@ export function encodeQR(text, output = 'raw', opts = {}) {
     let data, err = new Error('Unknown error');
     if (ver !== undefined) {
         validateVersion(ver);
-        data = encode(ver, ecc, text, encoding);
+        data = encode(ver, ecc, text, encoding, opts.textEncoder);
     }
     else {
         // If no version is provided, try to find smallest one which fits
         // Currently just scans all version, can be significantly speedup if needed
         for (let i = 1; i <= 40; i++) {
             try {
-                data = encode(i, ecc, text, encoding);
+                data = encode(i, ecc, text, encoding, opts.textEncoder);
                 ver = i;
                 break;
             }
@@ -1084,7 +1400,7 @@ export function encodeQR(text, output = 'raw', opts = {}) {
     if (opts.scale !== undefined)
         res = res.scale(opts.scale); // Scale image
     if (output === 'raw')
-        return res.data;
+        return res.toRaw();
     else if (output === 'ascii')
         return res.toASCII();
     else if (output === 'svg')
@@ -1100,6 +1416,7 @@ export default encodeQR;
 export const utils = {
     best,
     bin,
+    popcnt,
     drawTemplate,
     fillArr,
     info,