@lynx-js/qrcode-rsbuild-plugin 0.4.2 → 0.4.4

package/dist/760.js

@@ -0,0 +1,939 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { R } from "./8.js";
+var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2)=>{
+    QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
+    QrCodeDataType2[QrCodeDataType2["Data"] = 0] = "Data";
+    QrCodeDataType2[QrCodeDataType2["Function"] = 1] = "Function";
+    QrCodeDataType2[QrCodeDataType2["Position"] = 2] = "Position";
+    QrCodeDataType2[QrCodeDataType2["Timing"] = 3] = "Timing";
+    QrCodeDataType2[QrCodeDataType2["Alignment"] = 4] = "Alignment";
+    return QrCodeDataType2;
+})(QrCodeDataType || {});
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value)=>key in obj ? __defProp(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value
+    }) : obj[key] = value;
+var __publicField = (obj, key, value)=>{
+    __defNormalProp(obj, "symbol" != typeof key ? key + "" : key, value);
+    return value;
+};
+const LOW = [
+    0,
+    1
+];
+const MEDIUM = [
+    1,
+    0
+];
+const QUARTILE = [
+    2,
+    3
+];
+const HIGH = [
+    3,
+    2
+];
+const EccMap = {
+    L: LOW,
+    M: MEDIUM,
+    Q: QUARTILE,
+    H: HIGH
+};
+const NUMERIC_REGEX = /^[0-9]*$/;
+const ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
+const ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+const MIN_VERSION = 1;
+const MAX_VERSION = 40;
+const PENALTY_N1 = 3;
+const PENALTY_N2 = 3;
+const PENALTY_N3 = 40;
+const PENALTY_N4 = 10;
+const ECC_CODEWORDS_PER_BLOCK = [
+    [
+        -1,
+        7,
+        10,
+        15,
+        20,
+        26,
+        18,
+        20,
+        24,
+        30,
+        18,
+        20,
+        24,
+        26,
+        30,
+        22,
+        24,
+        28,
+        30,
+        28,
+        28,
+        28,
+        28,
+        30,
+        30,
+        26,
+        28,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30
+    ],
+    [
+        -1,
+        10,
+        16,
+        26,
+        18,
+        24,
+        16,
+        18,
+        22,
+        22,
+        26,
+        30,
+        22,
+        22,
+        24,
+        24,
+        28,
+        28,
+        26,
+        26,
+        26,
+        26,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28,
+        28
+    ],
+    [
+        -1,
+        13,
+        22,
+        18,
+        26,
+        18,
+        24,
+        18,
+        22,
+        20,
+        24,
+        28,
+        26,
+        24,
+        20,
+        30,
+        24,
+        28,
+        28,
+        26,
+        30,
+        28,
+        30,
+        30,
+        30,
+        30,
+        28,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30
+    ],
+    [
+        -1,
+        17,
+        28,
+        22,
+        16,
+        22,
+        28,
+        26,
+        26,
+        24,
+        28,
+        24,
+        28,
+        22,
+        24,
+        24,
+        30,
+        28,
+        28,
+        26,
+        28,
+        30,
+        24,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30,
+        30
+    ]
+];
+const NUM_ERROR_CORRECTION_BLOCKS = [
+    [
+        -1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        2,
+        2,
+        2,
+        2,
+        4,
+        4,
+        4,
+        4,
+        4,
+        6,
+        6,
+        6,
+        6,
+        7,
+        8,
+        8,
+        9,
+        9,
+        10,
+        12,
+        12,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        19,
+        20,
+        21,
+        22,
+        24,
+        25
+    ],
+    [
+        -1,
+        1,
+        1,
+        1,
+        2,
+        2,
+        4,
+        4,
+        4,
+        5,
+        5,
+        5,
+        8,
+        9,
+        9,
+        10,
+        10,
+        11,
+        13,
+        14,
+        16,
+        17,
+        17,
+        18,
+        20,
+        21,
+        23,
+        25,
+        26,
+        28,
+        29,
+        31,
+        33,
+        35,
+        37,
+        38,
+        40,
+        43,
+        45,
+        47,
+        49
+    ],
+    [
+        -1,
+        1,
+        1,
+        2,
+        2,
+        4,
+        4,
+        6,
+        6,
+        8,
+        8,
+        8,
+        10,
+        12,
+        16,
+        12,
+        17,
+        16,
+        18,
+        21,
+        20,
+        23,
+        23,
+        25,
+        27,
+        29,
+        34,
+        34,
+        35,
+        38,
+        40,
+        43,
+        45,
+        48,
+        51,
+        53,
+        56,
+        59,
+        62,
+        65,
+        68
+    ],
+    [
+        -1,
+        1,
+        1,
+        2,
+        4,
+        4,
+        4,
+        5,
+        6,
+        8,
+        8,
+        11,
+        11,
+        16,
+        16,
+        18,
+        16,
+        19,
+        21,
+        25,
+        25,
+        25,
+        34,
+        30,
+        32,
+        35,
+        37,
+        40,
+        42,
+        45,
+        48,
+        51,
+        54,
+        57,
+        60,
+        63,
+        66,
+        70,
+        74,
+        77,
+        81
+    ]
+];
+class QrCode {
+    constructor(version, ecc, dataCodewords, msk){
+        this.version = version;
+        this.ecc = ecc;
+        __publicField(this, "size");
+        __publicField(this, "mask");
+        __publicField(this, "modules", []);
+        __publicField(this, "types", []);
+        if (version < MIN_VERSION || version > MAX_VERSION) throw new RangeError("Version value out of range");
+        if (msk < -1 || msk > 7) throw new RangeError("Mask value out of range");
+        this.size = 4 * version + 17;
+        const row = Array.from({
+            length: this.size
+        }, ()=>false);
+        for(let i = 0; i < this.size; i++){
+            this.modules.push(row.slice());
+            this.types.push(row.map(()=>0));
+        }
+        this.drawFunctionPatterns();
+        const allCodewords = this.addEccAndInterleave(dataCodewords);
+        this.drawCodewords(allCodewords);
+        if (-1 === msk) {
+            let minPenalty = 1e9;
+            for(let i = 0; i < 8; i++){
+                this.applyMask(i);
+                this.drawFormatBits(i);
+                const penalty = this.getPenaltyScore();
+                if (penalty < minPenalty) {
+                    msk = i;
+                    minPenalty = penalty;
+                }
+                this.applyMask(i);
+            }
+        }
+        this.mask = msk;
+        this.applyMask(msk);
+        this.drawFormatBits(msk);
+    }
+    getModule(x, y) {
+        return x >= 0 && x < this.size && y >= 0 && y < this.size && this.modules[y][x];
+    }
+    drawFunctionPatterns() {
+        for(let i = 0; i < this.size; i++){
+            this.setFunctionModule(6, i, i % 2 === 0, QrCodeDataType.Timing);
+            this.setFunctionModule(i, 6, i % 2 === 0, QrCodeDataType.Timing);
+        }
+        this.drawFinderPattern(3, 3);
+        this.drawFinderPattern(this.size - 4, 3);
+        this.drawFinderPattern(3, this.size - 4);
+        const alignPatPos = this.getAlignmentPatternPositions();
+        const numAlign = alignPatPos.length;
+        for(let i = 0; i < numAlign; i++)for(let j = 0; j < numAlign; j++)if (!(0 === i && 0 === j || 0 === i && j === numAlign - 1 || i === numAlign - 1 && 0 === j)) this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+        this.drawFormatBits(0);
+        this.drawVersion();
+    }
+    drawFormatBits(mask) {
+        const data = this.ecc[1] << 3 | mask;
+        let rem = data;
+        for(let i = 0; i < 10; i++)rem = rem << 1 ^ (rem >>> 9) * 1335;
+        const bits = (data << 10 | rem) ^ 21522;
+        for(let i = 0; i <= 5; i++)this.setFunctionModule(8, i, getBit(bits, i));
+        this.setFunctionModule(8, 7, getBit(bits, 6));
+        this.setFunctionModule(8, 8, getBit(bits, 7));
+        this.setFunctionModule(7, 8, getBit(bits, 8));
+        for(let i = 9; i < 15; i++)this.setFunctionModule(14 - i, 8, getBit(bits, i));
+        for(let i = 0; i < 8; i++)this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+        for(let i = 8; i < 15; i++)this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+        this.setFunctionModule(8, this.size - 8, true);
+    }
+    drawVersion() {
+        if (this.version < 7) return;
+        let rem = this.version;
+        for(let i = 0; i < 12; i++)rem = rem << 1 ^ (rem >>> 11) * 7973;
+        const bits = this.version << 12 | rem;
+        for(let i = 0; i < 18; i++){
+            const color = getBit(bits, i);
+            const a = this.size - 11 + i % 3;
+            const b = Math.floor(i / 3);
+            this.setFunctionModule(a, b, color);
+            this.setFunctionModule(b, a, color);
+        }
+    }
+    drawFinderPattern(x, y) {
+        for(let dy = -4; dy <= 4; dy++)for(let dx = -4; dx <= 4; dx++){
+            const dist = Math.max(Math.abs(dx), Math.abs(dy));
+            const xx = x + dx;
+            const yy = y + dy;
+            if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size) this.setFunctionModule(xx, yy, 2 !== dist && 4 !== dist, QrCodeDataType.Position);
+        }
+    }
+    drawAlignmentPattern(x, y) {
+        for(let dy = -2; dy <= 2; dy++)for(let dx = -2; dx <= 2; dx++)this.setFunctionModule(x + dx, y + dy, 1 !== Math.max(Math.abs(dx), Math.abs(dy)), QrCodeDataType.Alignment);
+    }
+    setFunctionModule(x, y, isDark, type = QrCodeDataType.Function) {
+        this.modules[y][x] = isDark;
+        this.types[y][x] = type;
+    }
+    addEccAndInterleave(data) {
+        const ver = this.version;
+        const ecl = this.ecc;
+        if (data.length !== getNumDataCodewords(ver, ecl)) throw new RangeError("Invalid argument");
+        const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+        const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver];
+        const rawCodewords = Math.floor(getNumRawDataModules(ver) / 8);
+        const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+        const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+        const blocks = [];
+        const rsDiv = reedSolomonComputeDivisor(blockEccLen);
+        for(let i = 0, k = 0; i < numBlocks; i++){
+            const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+            k += dat.length;
+            const ecc = reedSolomonComputeRemainder(dat, rsDiv);
+            if (i < numShortBlocks) dat.push(0);
+            blocks.push(dat.concat(ecc));
+        }
+        const result = [];
+        for(let i = 0; i < blocks[0].length; i++)blocks.forEach((block, j)=>{
+            if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(block[i]);
+        });
+        return result;
+    }
+    drawCodewords(data) {
+        if (data.length !== Math.floor(getNumRawDataModules(this.version) / 8)) throw new RangeError("Invalid argument");
+        let i = 0;
+        for(let right = this.size - 1; right >= 1; right -= 2){
+            if (6 === right) right = 5;
+            for(let vert = 0; vert < this.size; vert++)for(let j = 0; j < 2; j++){
+                const x = right - j;
+                const upward = (right + 1 & 2) === 0;
+                const y = upward ? this.size - 1 - vert : vert;
+                if (!this.types[y][x] && i < 8 * data.length) {
+                    this.modules[y][x] = getBit(data[i >>> 3], 7 - (7 & i));
+                    i++;
+                }
+            }
+        }
+    }
+    applyMask(mask) {
+        if (mask < 0 || mask > 7) throw new RangeError("Mask value out of range");
+        for(let y = 0; y < this.size; y++)for(let x = 0; x < this.size; x++){
+            let invert;
+            switch(mask){
+                case 0:
+                    invert = (x + y) % 2 === 0;
+                    break;
+                case 1:
+                    invert = y % 2 === 0;
+                    break;
+                case 2:
+                    invert = x % 3 === 0;
+                    break;
+                case 3:
+                    invert = (x + y) % 3 === 0;
+                    break;
+                case 4:
+                    invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+                    break;
+                case 5:
+                    invert = x * y % 2 + x * y % 3 === 0;
+                    break;
+                case 6:
+                    invert = (x * y % 2 + x * y % 3) % 2 === 0;
+                    break;
+                case 7:
+                    invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
+                    break;
+                default:
+                    throw new Error("Unreachable");
+            }
+            if (!this.types[y][x] && invert) this.modules[y][x] = !this.modules[y][x];
+        }
+    }
+    getPenaltyScore() {
+        let result = 0;
+        for(let y = 0; y < this.size; y++){
+            let runColor = false;
+            let runX = 0;
+            const runHistory = [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+            ];
+            for(let x = 0; x < this.size; x++)if (this.modules[y][x] === runColor) {
+                runX++;
+                if (5 === runX) result += PENALTY_N1;
+                else if (runX > 5) result++;
+            } else {
+                this.finderPenaltyAddHistory(runX, runHistory);
+                if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+                runColor = this.modules[y][x];
+                runX = 1;
+            }
+            result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+        }
+        for(let x = 0; x < this.size; x++){
+            let runColor = false;
+            let runY = 0;
+            const runHistory = [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+            ];
+            for(let y = 0; y < this.size; y++)if (this.modules[y][x] === runColor) {
+                runY++;
+                if (5 === runY) result += PENALTY_N1;
+                else if (runY > 5) result++;
+            } else {
+                this.finderPenaltyAddHistory(runY, runHistory);
+                if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+                runColor = this.modules[y][x];
+                runY = 1;
+            }
+            result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+        }
+        for(let y = 0; y < this.size - 1; y++)for(let x = 0; x < this.size - 1; x++){
+            const color = this.modules[y][x];
+            if (color === this.modules[y][x + 1] && color === this.modules[y + 1][x] && color === this.modules[y + 1][x + 1]) result += PENALTY_N2;
+        }
+        let dark = 0;
+        for (const row of this.modules)dark = row.reduce((sum, color)=>sum + (color ? 1 : 0), dark);
+        const total = this.size * this.size;
+        const k = Math.ceil(Math.abs(20 * dark - 10 * total) / total) - 1;
+        result += k * PENALTY_N4;
+        return result;
+    }
+    getAlignmentPatternPositions() {
+        if (1 === this.version) return [];
+        {
+            const numAlign = Math.floor(this.version / 7) + 2;
+            const step = 32 === this.version ? 26 : 2 * Math.ceil((4 * this.version + 4) / (2 * numAlign - 2));
+            const result = [
+                6
+            ];
+            for(let pos = this.size - 7; result.length < numAlign; pos -= step)result.splice(1, 0, pos);
+            return result;
+        }
+    }
+    finderPenaltyCountPatterns(runHistory) {
+        const n = runHistory[1];
+        const core = n > 0 && runHistory[2] === n && runHistory[3] === 3 * n && runHistory[4] === n && runHistory[5] === n;
+        return (core && runHistory[0] >= 4 * n && runHistory[6] >= n ? 1 : 0) + (core && runHistory[6] >= 4 * n && runHistory[0] >= n ? 1 : 0);
+    }
+    finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
+        if (currentRunColor) {
+            this.finderPenaltyAddHistory(currentRunLength, runHistory);
+            currentRunLength = 0;
+        }
+        currentRunLength += this.size;
+        this.finderPenaltyAddHistory(currentRunLength, runHistory);
+        return this.finderPenaltyCountPatterns(runHistory);
+    }
+    finderPenaltyAddHistory(currentRunLength, runHistory) {
+        if (0 === runHistory[0]) currentRunLength += this.size;
+        runHistory.pop();
+        runHistory.unshift(currentRunLength);
+    }
+}
+function appendBits(val, len, bb) {
+    if (len < 0 || len > 31 || val >>> len !== 0) throw new RangeError("Value out of range");
+    for(let i = len - 1; i >= 0; i--)bb.push(val >>> i & 1);
+}
+function getBit(x, i) {
+    return (x >>> i & 1) !== 0;
+}
+class QrSegment {
+    constructor(mode, numChars, bitData){
+        this.mode = mode;
+        this.numChars = numChars;
+        this.bitData = bitData;
+        if (numChars < 0) throw new RangeError("Invalid argument");
+        this.bitData = bitData.slice();
+    }
+    getData() {
+        return this.bitData.slice();
+    }
+}
+const MODE_NUMERIC = [
+    1,
+    10,
+    12,
+    14
+];
+const MODE_ALPHANUMERIC = [
+    2,
+    9,
+    11,
+    13
+];
+const MODE_BYTE = [
+    4,
+    8,
+    16,
+    16
+];
+function numCharCountBits(mode, ver) {
+    return mode[Math.floor((ver + 7) / 17) + 1];
+}
+function makeBytes(data) {
+    const bb = [];
+    for (const b of data)appendBits(b, 8, bb);
+    return new QrSegment(MODE_BYTE, data.length, bb);
+}
+function makeNumeric(digits) {
+    if (!isNumeric(digits)) throw new RangeError("String contains non-numeric characters");
+    const bb = [];
+    for(let i = 0; i < digits.length;){
+        const n = Math.min(digits.length - i, 3);
+        appendBits(Number.parseInt(digits.substring(i, i + n), 10), 3 * n + 1, bb);
+        i += n;
+    }
+    return new QrSegment(MODE_NUMERIC, digits.length, bb);
+}
+function makeAlphanumeric(text) {
+    if (!isAlphanumeric(text)) throw new RangeError("String contains unencodable characters in alphanumeric mode");
+    const bb = [];
+    let i;
+    for(i = 0; i + 2 <= text.length; i += 2){
+        let temp = 45 * ALPHANUMERIC_CHARSET.indexOf(text.charAt(i));
+        temp += ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+        appendBits(temp, 11, bb);
+    }
+    if (i < text.length) appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+    return new QrSegment(MODE_ALPHANUMERIC, text.length, bb);
+}
+function makeSegments(text) {
+    if ("" === text) return [];
+    if (isNumeric(text)) return [
+        makeNumeric(text)
+    ];
+    if (isAlphanumeric(text)) return [
+        makeAlphanumeric(text)
+    ];
+    return [
+        makeBytes(toUtf8ByteArray(text))
+    ];
+}
+function isNumeric(text) {
+    return NUMERIC_REGEX.test(text);
+}
+function isAlphanumeric(text) {
+    return ALPHANUMERIC_REGEX.test(text);
+}
+function getTotalBits(segs, version) {
+    let result = 0;
+    for (const seg of segs){
+        const ccbits = numCharCountBits(seg.mode, version);
+        if (seg.numChars >= 1 << ccbits) return 1 / 0;
+        result += 4 + ccbits + seg.bitData.length;
+    }
+    return result;
+}
+function toUtf8ByteArray(str) {
+    str = encodeURI(str);
+    const result = [];
+    for(let i = 0; i < str.length; i++)if ("%" !== str.charAt(i)) result.push(str.charCodeAt(i));
+    else {
+        result.push(Number.parseInt(str.substring(i + 1, i + 3), 16));
+        i += 2;
+    }
+    return result;
+}
+function getNumRawDataModules(ver) {
+    if (ver < MIN_VERSION || ver > MAX_VERSION) throw new RangeError("Version number out of range");
+    let result = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+        const numAlign = Math.floor(ver / 7) + 2;
+        result -= (25 * numAlign - 10) * numAlign - 55;
+        if (ver >= 7) result -= 36;
+    }
+    return result;
+}
+function getNumDataCodewords(ver, ecl) {
+    return Math.floor(getNumRawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver] * NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+}
+function reedSolomonComputeDivisor(degree) {
+    if (degree < 1 || degree > 255) throw new RangeError("Degree out of range");
+    const result = [];
+    for(let i = 0; i < degree - 1; i++)result.push(0);
+    result.push(1);
+    let root = 1;
+    for(let i = 0; i < degree; i++){
+        for(let j = 0; j < result.length; j++){
+            result[j] = reedSolomonMultiply(result[j], root);
+            if (j + 1 < result.length) result[j] ^= result[j + 1];
+        }
+        root = reedSolomonMultiply(root, 2);
+    }
+    return result;
+}
+function reedSolomonComputeRemainder(data, divisor) {
+    const result = divisor.map((_)=>0);
+    for (const b of data){
+        const factor = b ^ result.shift();
+        result.push(0);
+        divisor.forEach((coef, i)=>result[i] ^= reedSolomonMultiply(coef, factor));
+    }
+    return result;
+}
+function reedSolomonMultiply(x, y) {
+    if (x >>> 8 !== 0 || y >>> 8 !== 0) throw new RangeError("Byte out of range");
+    let z = 0;
+    for(let i = 7; i >= 0; i--){
+        z = z << 1 ^ (z >>> 7) * 285;
+        z ^= (y >>> i & 1) * x;
+    }
+    return z;
+}
+function encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
+    if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) throw new RangeError("Invalid value");
+    let version;
+    let dataUsedBits;
+    for(version = minVersion;; version++){
+        const dataCapacityBits2 = 8 * getNumDataCodewords(version, ecl);
+        const usedBits = getTotalBits(segs, version);
+        if (usedBits <= dataCapacityBits2) {
+            dataUsedBits = usedBits;
+            break;
+        }
+        if (version >= maxVersion) throw new RangeError("Data too long");
+    }
+    for (const newEcl of [
+        MEDIUM,
+        QUARTILE,
+        HIGH
+    ])if (boostEcl && dataUsedBits <= 8 * getNumDataCodewords(version, newEcl)) ecl = newEcl;
+    const bb = [];
+    for (const seg of segs){
+        appendBits(seg.mode[0], 4, bb);
+        appendBits(seg.numChars, numCharCountBits(seg.mode, version), bb);
+        for (const b of seg.getData())bb.push(b);
+    }
+    const dataCapacityBits = 8 * getNumDataCodewords(version, ecl);
+    appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+    appendBits(0, (8 - bb.length % 8) % 8, bb);
+    for(let padByte = 236; bb.length < dataCapacityBits; padByte ^= 253)appendBits(padByte, 8, bb);
+    const dataCodewords = Array.from({
+        length: Math.ceil(bb.length / 8)
+    }, ()=>0);
+    bb.forEach((b, i)=>dataCodewords[i >>> 3] |= b << 7 - (7 & i));
+    return new QrCode(version, ecl, dataCodewords, mask);
+}
+function encode(data, options) {
+    const { ecc = "L", boostEcc = false, minVersion = 1, maxVersion = 40, maskPattern = -1, border = 1 } = options || {};
+    const segment = "string" == typeof data ? makeSegments(data) : Array.isArray(data) ? [
+        makeBytes(data)
+    ] : void 0;
+    if (!segment) throw new Error(`uqr only supports encoding string and binary data, but got: ${typeof data}`);
+    const qr = encodeSegments(segment, EccMap[ecc], minVersion, maxVersion, maskPattern, boostEcc);
+    const result = addBorder({
+        version: qr.version,
+        maskPattern: qr.mask,
+        size: qr.size,
+        data: qr.modules,
+        types: qr.types
+    }, border);
+    if (options?.invert) result.data = result.data.map((row)=>row.map((mod)=>!mod));
+    options?.onEncoded?.(result);
+    return result;
+}
+function addBorder(input, border = 1) {
+    if (!border) return input;
+    const { size } = input;
+    const newSize = size + 2 * border;
+    input.size = newSize;
+    input.data.forEach((row)=>{
+        for(let i = 0; i < border; i++){
+            row.unshift(false);
+            row.push(false);
+        }
+    });
+    for(let i = 0; i < border; i++){
+        input.data.unshift(Array.from({
+            length: newSize
+        }, (_)=>false));
+        input.data.push(Array.from({
+            length: newSize
+        }, (_)=>false));
+    }
+    const b = QrCodeDataType.Border;
+    input.types.forEach((row)=>{
+        for(let i = 0; i < border; i++){
+            row.unshift(b);
+            row.push(b);
+        }
+    });
+    for(let i = 0; i < border; i++){
+        input.types.unshift(Array.from({
+            length: newSize
+        }, (_)=>b));
+        input.types.push(Array.from({
+            length: newSize
+        }, (_)=>b));
+    }
+    return input;
+}
+function getDataAt(data, x, y, defaults = false) {
+    if (x < 0 || y < 0 || x >= data.length || y >= data.length) return defaults;
+    return data[y][x];
+}
+function renderUnicodeCompact(data, options = {}) {
+    const platte = {
+        WHITE_ALL: "\u2588",
+        WHITE_BLACK: "\u2580",
+        BLACK_WHITE: "\u2584",
+        BLACK_ALL: " "
+    };
+    const result = encode(data, options);
+    const WHITE = false;
+    const BLACK = true;
+    const at = (x, y)=>getDataAt(result.data, x, y, true);
+    const lines = [];
+    let line = "";
+    for(let row = 0; row < result.size; row += 2){
+        for(let col = 0; col < result.size; col++)if (at(col, row) === WHITE && at(col, row + 1) === WHITE) line += platte.WHITE_ALL;
+        else if (at(col, row) === WHITE && at(col, row + 1) === BLACK) line += platte.WHITE_BLACK;
+        else if (at(col, row) === BLACK && at(col, row + 1) === WHITE) line += platte.BLACK_WHITE;
+        else line += platte.BLACK_ALL;
+        lines.push(line);
+        line = "";
+    }
+    return lines.join("\n");
+}
+const picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+function showQRCode(url) {
+    R.info(picocolors_default().green('Scan with Lynx'));
+    R.success(renderUnicodeCompact(url));
+    R.success(url);
+}
+export { showQRCode };