react-native-inapp-inspector 2.3.13 → 2.3.15

package/dist/esm/helpers/qrGenerator.js

@@ -1,38 +1,364 @@
-import qrcode from 'qrcode-generator';
+const QR_ECC_LEVEL = {
+    L: 1,
+    M: 0,
+    Q: 3,
+    H: 2,
+};
+const EXP_TABLE = new Uint8Array(256);
+const LOG_TABLE = new Uint8Array(256);
+(function initGaloisField() {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+        EXP_TABLE[i] = x;
+        LOG_TABLE[x] = i;
+        x <<= 1;
+        if (x & 0x100) {
+            x ^= 0x11d;
+        }
+    }
+    EXP_TABLE[255] = EXP_TABLE[0];
+})();
+function glog(n) {
+    if (n < 1)
+        throw new Error(`glog(${n})`);
+    return LOG_TABLE[n];
+}
+function gexp(n) {
+    while (n < 0)
+        n += 255;
+    while (n >= 256)
+        n -= 255;
+    return EXP_TABLE[n];
+}
+class Polynomial {
+    constructor(num, shift = 0) {
+        let offset = 0;
+        while (offset < num.length && num[offset] === 0) {
+            offset++;
+        }
+        this.num = new Array(num.length - offset + shift);
+        for (let i = 0; i < num.length - offset; i++) {
+            this.num[i] = num[i + offset];
+        }
+        for (let i = num.length - offset; i < this.num.length; i++) {
+            this.num[i] = 0;
+        }
+    }
+    get(index) {
+        return this.num[index] || 0;
+    }
+    getLength() {
+        return this.num.length;
+    }
+    multiply(e) {
+        const num = new Array(this.getLength() + e.getLength() - 1).fill(0);
+        for (let i = 0; i < this.getLength(); i++) {
+            for (let j = 0; j < e.getLength(); j++) {
+                num[i + j] ^= gexp(glog(this.get(i)) + glog(e.get(j)));
+            }
+        }
+        return new Polynomial(num);
+    }
+    mod(e) {
+        if (this.getLength() - e.getLength() < 0) {
+            return this;
+        }
+        const ratio = glog(this.get(0)) - glog(e.get(0));
+        const num = new Array(this.getLength());
+        for (let i = 0; i < this.getLength(); i++) {
+            num[i] = this.get(i);
+        }
+        for (let i = 0; i < e.getLength(); i++) {
+            num[i] ^= gexp(glog(e.get(i)) + ratio);
+        }
+        return new Polynomial(num).mod(e);
+    }
+}
+const RS_BLOCK_TABLE = [
+    [[1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9]],
+    [[1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16]],
+    [[1, 70, 55], [1, 70, 44], [2, 35, 17], [2, 35, 13]],
+    [[1, 100, 80], [2, 50, 32], [2, 50, 24], [4, 25, 9]],
+    [[1, 134, 108], [2, 67, 43], [2, 33, 15, 2, 34, 16], [2, 33, 11, 2, 34, 12]],
+    [[2, 86, 68], [4, 43, 27], [4, 43, 19], [4, 43, 15]],
+    [[2, 98, 78], [4, 49, 31], [2, 32, 14, 4, 33, 15], [4, 39, 13, 1, 40, 14]],
+    [[2, 121, 97], [2, 60, 38, 2, 61, 39], [4, 40, 18, 2, 41, 19], [4, 40, 14, 2, 41, 15]],
+    [[2, 146, 116], [3, 58, 36, 2, 59, 37], [4, 36, 16, 4, 37, 17], [4, 36, 12, 4, 37, 13]],
+    [[2, 86, 68, 2, 87, 69], [4, 69, 43, 1, 70, 44], [6, 43, 19, 2, 44, 20], [6, 43, 15, 2, 44, 16]],
+];
+const PATTERN_POSITION_TABLE = [
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+];
+const G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0);
+const G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1);
+function getBCHTypeInfo(data) {
+    let d = data << 10;
+    while (getBCHDigit(d) - getBCHDigit(G15) >= 0) {
+        d ^= G15 << (getBCHDigit(d) - getBCHDigit(G15));
+    }
+    return ((data << 10) | d) ^ G15_MASK;
+}
+function getBCHDigit(data) {
+    let digit = 0;
+    while (data !== 0) {
+        digit++;
+        data >>>= 1;
+    }
+    return digit;
+}
+function getMask(maskPattern, i, j) {
+    switch (maskPattern) {
+        case 0: return (i + j) % 2 === 0;
+        case 1: return i % 2 === 0;
+        case 2: return j % 3 === 0;
+        case 3: return (i + j) % 3 === 0;
+        case 4: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+        case 5: return ((i * j) % 2) + ((i * j) % 3) === 0;
+        case 6: return (((i * j) % 2) + ((i * j) % 3)) % 2 === 0;
+        case 7: return (((i * j) % 3) + ((i + j) % 2)) % 2 === 0;
+        default: return false;
+    }
+}
+class BitBuffer {
+    constructor() {
+        this.buffer = [];
+        this.length = 0;
+    }
+    get(index) {
+        const bufIndex = Math.floor(index / 8);
+        return ((this.buffer[bufIndex] >>> (7 - (index % 8))) & 1) === 1;
+    }
+    put(num, length) {
+        for (let i = 0; i < length; i++) {
+            this.putBit(((num >>> (length - i - 1)) & 1) === 1);
+        }
+    }
+    putBit(bit) {
+        const bufIndex = Math.floor(this.length / 8);
+        if (this.buffer.length <= bufIndex) {
+            this.buffer.push(0);
+        }
+        if (bit) {
+            this.buffer[bufIndex] |= 0x80 >>> (this.length % 8);
+        }
+        this.length++;
+    }
+}
+function getErrorCorrectionPolynomial(errorCorrectionLength) {
+    let a = new Polynomial([1], 0);
+    for (let i = 0; i < errorCorrectionLength; i++) {
+        a = a.multiply(new Polynomial([1, gexp(i)], 0));
+    }
+    return a;
+}
 export function generateQRMatrix(text, ecc = 'M') {
-    try {
-        const qr = qrcode(0, ecc);
-        qr.addData(text);
-        qr.make();
-        const count = qr.getModuleCount();
-        const matrix = [];
-        for (let row = 0; row < count; row++) {
-            const rowData = [];
-            for (let col = 0; col < count; col++) {
-                rowData.push(qr.isDark(row, col));
+    const eccLevel = QR_ECC_LEVEL[ecc] ?? 0;
+    const utf8Bytes = [];
+    for (let i = 0; i < text.length; i++) {
+        let c = text.charCodeAt(i);
+        if (c < 128) {
+            utf8Bytes.push(c);
+        }
+        else if (c < 2048) {
+            utf8Bytes.push((c >> 6) | 192);
+            utf8Bytes.push((c & 63) | 128);
+        }
+        else {
+            utf8Bytes.push((c >> 12) | 224);
+            utf8Bytes.push(((c >> 6) & 63) | 128);
+            utf8Bytes.push((c & 63) | 128);
+        }
+    }
+    let version = 1;
+    for (let v = 1; v <= 10; v++) {
+        const blockList = RS_BLOCK_TABLE[v - 1][eccLevel];
+        let totalDataCount = 0;
+        for (let i = 0; i < blockList.length; i += 3) {
+            totalDataCount += blockList[i] * blockList[i + 2];
+        }
+        if (utf8Bytes.length + 2 <= totalDataCount) {
+            version = v;
+            break;
+        }
+        version = v;
+    }
+    const moduleCount = version * 4 + 17;
+    const modules = Array.from({ length: moduleCount }, () => Array(moduleCount).fill(null));
+    function setupPositionProbePattern(row, col) {
+        for (let r = -1; r <= 7; r++) {
+            if (row + r <= -1 || moduleCount <= row + r)
+                continue;
+            for (let c = -1; c <= 7; c++) {
+                if (col + c <= -1 || moduleCount <= col + c)
+                    continue;
+                if ((0 <= r && r <= 6 && (c === 0 || c === 6)) ||
+                    (0 <= c && c <= 6 && (r === 0 || r === 6)) ||
+                    (2 <= r && r <= 4 && 2 <= c && c <= 4)) {
+                    modules[row + r][col + c] = true;
+                }
+                else {
+                    modules[row + r][col + c] = false;
+                }
             }
-            matrix.push(rowData);
-        }
-        return matrix;
-    }
-    catch (err) {
-        try {
-            const qr = qrcode(10, ecc);
-            qr.addData(text);
-            qr.make();
-            const count = qr.getModuleCount();
-            const matrix = [];
-            for (let row = 0; row < count; row++) {
-                const rowData = [];
-                for (let col = 0; col < count; col++) {
-                    rowData.push(qr.isDark(row, col));
+        }
+    }
+    setupPositionProbePattern(0, 0);
+    setupPositionProbePattern(moduleCount - 7, 0);
+    setupPositionProbePattern(0, moduleCount - 7);
+    const pos = PATTERN_POSITION_TABLE[version - 1] || [];
+    for (let i = 0; i < pos.length; i++) {
+        for (let j = 0; j < pos.length; j++) {
+            const row = pos[i];
+            const col = pos[j];
+            if (modules[row][col] !== null)
+                continue;
+            for (let r = -2; r <= 2; r++) {
+                for (let c = -2; c <= 2; c++) {
+                    if (r === -2 || r === 2 || c === -2 || c === 2 || (r === 0 && c === 0)) {
+                        modules[row + r][col + c] = true;
+                    }
+                    else {
+                        modules[row + r][col + c] = false;
+                    }
                 }
-                matrix.push(rowData);
             }
-            return matrix;
         }
-        catch {
-            return [];
+    }
+    for (let r = 8; r < moduleCount - 8; r++) {
+        if (modules[r][6] === null)
+            modules[r][6] = r % 2 === 0;
+    }
+    for (let c = 8; c < moduleCount - 8; c++) {
+        if (modules[6][c] === null)
+            modules[6][c] = c % 2 === 0;
+    }
+    const buffer = new BitBuffer();
+    buffer.put(4, 4);
+    buffer.put(utf8Bytes.length, 8);
+    for (let i = 0; i < utf8Bytes.length; i++) {
+        buffer.put(utf8Bytes[i], 8);
+    }
+    const rsBlocks = RS_BLOCK_TABLE[version - 1][eccLevel];
+    let totalDataCount = 0;
+    for (let i = 0; i < rsBlocks.length; i += 3) {
+        totalDataCount += rsBlocks[i] * rsBlocks[i + 2];
+    }
+    if (buffer.length + 4 <= totalDataCount * 8) {
+        buffer.put(0, 4);
+    }
+    while (buffer.length % 8 !== 0) {
+        buffer.putBit(false);
+    }
+    while (buffer.length < totalDataCount * 8) {
+        buffer.put(0xec, 8);
+        if (buffer.length < totalDataCount * 8) {
+            buffer.put(0x11, 8);
+        }
+    }
+    const dataBytes = buffer.buffer;
+    let offset = 0;
+    const dcData = [];
+    const ecData = [];
+    for (let i = 0; i < rsBlocks.length; i += 3) {
+        const numBlocks = rsBlocks[i];
+        const totalCount = rsBlocks[i + 1];
+        const dataCount = rsBlocks[i + 2];
+        const ecCount = totalCount - dataCount;
+        const rsPoly = getErrorCorrectionPolynomial(ecCount);
+        for (let b = 0; b < numBlocks; b++) {
+            const rawDc = dataBytes.slice(offset, offset + dataCount);
+            offset += dataCount;
+            dcData.push(rawDc);
+            const rawPoly = new Polynomial(rawDc, rsPoly.getLength() - 1);
+            const modPoly = rawPoly.mod(rsPoly);
+            const ec = new Array(rsPoly.getLength() - 1).fill(0);
+            for (let k = 0; k < ec.length; k++) {
+                const modIndex = k + modPoly.getLength() - ec.length;
+                ec[k] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
+            }
+            ecData.push(ec);
+        }
+    }
+    const finalCodewords = [];
+    let maxDcCount = 0;
+    for (const block of dcData)
+        maxDcCount = Math.max(maxDcCount, block.length);
+    for (let i = 0; i < maxDcCount; i++) {
+        for (const block of dcData) {
+            if (i < block.length)
+                finalCodewords.push(block[i]);
+        }
+    }
+    let maxEcCount = 0;
+    for (const block of ecData)
+        maxEcCount = Math.max(maxEcCount, block.length);
+    for (let i = 0; i < maxEcCount; i++) {
+        for (const block of ecData) {
+            if (i < block.length)
+                finalCodewords.push(block[i]);
+        }
+    }
+    let inc = -1;
+    let row = moduleCount - 1;
+    let bitIndex = 0;
+    const maskPattern = 0;
+    for (let col = moduleCount - 1; col > 0; col -= 2) {
+        if (col === 6)
+            col--;
+        while (true) {
+            for (let c = 0; c < 2; c++) {
+                if (modules[row][col - c] === null) {
+                    let dark = false;
+                    if (bitIndex < finalCodewords.length * 8) {
+                        const byte = finalCodewords[Math.floor(bitIndex / 8)];
+                        dark = ((byte >>> (7 - (bitIndex % 8))) & 1) === 1;
+                        bitIndex++;
+                    }
+                    const mask = getMask(maskPattern, row, col - c);
+                    modules[row][col - c] = mask ? !dark : dark;
+                }
+            }
+            row += inc;
+            if (row < 0 || moduleCount <= row) {
+                row -= inc;
+                inc = -inc;
+                break;
+            }
+        }
+    }
+    const typeData = (eccLevel << 3) | maskPattern;
+    const bits = getBCHTypeInfo(typeData);
+    for (let i = 0; i < 15; i++) {
+        const mod = ((bits >> i) & 1) === 1;
+        if (i < 6) {
+            modules[i][8] = mod;
+        }
+        else if (i < 8) {
+            modules[i + 1][8] = mod;
+        }
+        else {
+            modules[moduleCount - 15 + i][8] = mod;
+        }
+        if (i < 8) {
+            modules[8][moduleCount - i - 1] = mod;
+        }
+        else if (i < 9) {
+            modules[8][15 - i - 1 + 1] = mod;
+        }
+        else {
+            modules[8][15 - i - 1] = mod;
         }
     }
+    modules[moduleCount - 8][8] = true;
+    return modules.map(r => r.map(cell => cell === true));
 }
+export default generateQRMatrix;

package/dist/esm/helpers/searchQueryParser.d.ts

@@ -4,4 +4,4 @@ export interface SearchQueryOptions {
     isRegex?: boolean;
     isCaseSensitive?: boolean;
 }
-export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string, options?: SearchQueryOptions): boolean;
+export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string, _options?: SearchQueryOptions): boolean;