@vkontakte/vk-qr 2.0.13 → 3.0.0

package/dist/index.js

@@ -0,0 +1,1135 @@
+import { _ as _define_property__ } from "@swc/helpers/_/_define_property";
+const MULTI = 1;
+const QR_BORDER = 7;
+const TILE_SIZE = 96 * MULTI;
+const SMALL_QR_SIZE = 25;
+const getPixel = (x, y, size, modules, isLogoShowed)=>{
+    if (x < QR_BORDER && y < QR_BORDER) return false;
+    if (x >= size - QR_BORDER && y < QR_BORDER) return false;
+    if (x < QR_BORDER && y >= size - QR_BORDER) return false;
+    if (isLogoShowed) {
+        let imageTiles = QR_BORDER + 2;
+        if (size <= SMALL_QR_SIZE) imageTiles--;
+        let paddingTiles = (size - 2 * QR_BORDER - imageTiles) / 2 - 1;
+        if (size <= SMALL_QR_SIZE) paddingTiles++;
+        if (x > QR_BORDER + paddingTiles && x < size - QR_BORDER - paddingTiles - 1 && y > QR_BORDER + paddingTiles && y < size - QR_BORDER - paddingTiles - 1) return false;
+        return 0 <= x && x < size && 0 <= y && y < size && modules[y][x];
+    }
+    return modules[y]?.[x];
+};
+const getNeighbors = (x, y, size, modules, isLogoShowed = true)=>({
+        l: getPixel(x - 1, y, size, modules, isLogoShowed),
+        r: getPixel(x + 1, y, size, modules, isLogoShowed),
+        t: getPixel(x, y - 1, size, modules, isLogoShowed),
+        b: getPixel(x, y + 1, size, modules, isLogoShowed),
+        current: getPixel(x, y, size, modules, isLogoShowed)
+    });
+const convertSegmentsToSvgString = (qrCode, options)=>{
+    if ('number' != typeof options.qrSize) throw new Error('Size should be a number');
+    if ('string' != typeof options.className) throw new Error('Classname should be a string');
+    const _2 = 2 * MULTI;
+    const _12_7 = 12.7 * MULTI;
+    const _12_8 = 12.8 * MULTI;
+    const _14_7 = 14.7 * MULTI;
+    const _14_8 = 14.8 * MULTI;
+    const _15_9 = 15.9 * MULTI;
+    const _28_6 = 28.6 * MULTI;
+    const _30_5 = 30.5 * MULTI;
+    const _84_7 = 84.7776815 * MULTI;
+    const _87_3 = 87.3 * MULTI;
+    const _71_4 = 71.4 * MULTI;
+    const _42_9 = 42.9 * MULTI;
+    const _87_2 = 87.2 * MULTI;
+    const _85_2 = 85.2 * MULTI;
+    const _85_3 = 85.3 * MULTI;
+    const _69_5 = 69.5 * MULTI;
+    const _98 = 98 * MULTI;
+    const _100 = 100 * MULTI;
+    const parts = [];
+    let leftPadding = 0;
+    let topPadding = 0;
+    let xCoord = 0;
+    let yCoord = 0;
+    for(let y = 0; y < qrCode.size; y++){
+        leftPadding = 0;
+        for(let x = 0; x < qrCode.size; x++){
+            xCoord = x + leftPadding;
+            leftPadding += TILE_SIZE;
+            yCoord = y + topPadding;
+            const neighbors = getNeighbors(x, y, qrCode.size, qrCode.modules, options.isShowLogo);
+            let path = '';
+            let selector = '';
+            if (neighbors.current) {
+                selector = selector || neighbors.l || neighbors.r || neighbors.t || neighbors.b ? '' : 'empty';
+                selector = !selector && neighbors.l && neighbors.r || neighbors.t && neighbors.b ? 'rect' : '';
+                if (!selector) {
+                    selector += neighbors.l ? 'l' : neighbors.r ? 'r' : '';
+                    selector += neighbors.t ? 't' : neighbors.b ? 'b' : '';
+                    if (!selector) selector = 'empty';
+                }
+            } else {
+                selector = !selector && neighbors.l && neighbors.t && getPixel(x - 1, y - 1, qrCode.size, qrCode.modules, options.isShowLogo) ? 'n_lt' : '';
+                selector = !selector && neighbors.l && neighbors.b && getPixel(x - 1, y + 1, qrCode.size, qrCode.modules, options.isShowLogo) ? 'n_lb' : '';
+                selector = !selector && neighbors.r && neighbors.t && getPixel(x + 1, y - 1, qrCode.size, qrCode.modules, options.isShowLogo) ? 'n_rt' : '';
+                selector = !selector && neighbors.r && neighbors.b && getPixel(x + 1, y + 1, qrCode.size, qrCode.modules, options.isShowLogo) ? 'n_rb' : '';
+            }
+            if (selector) {
+                path = `<use xlink:href="#${selector}-${options.suffix}"/>`;
+                parts.push(`<g transform="translate(${xCoord},${yCoord})">${path}</g>`);
+            }
+        }
+        topPadding += TILE_SIZE;
+    }
+    let scale = '';
+    let position = (qrCode.size - 3 * QR_BORDER) / 2 * TILE_SIZE + TILE_SIZE * QR_BORDER - 10;
+    if (qrCode.size <= SMALL_QR_SIZE) {
+        scale = 'scale(0.85)';
+        position += 50;
+    }
+    const pointPosition = (qrCode.size - QR_BORDER) * options.incTileSize;
+    parts.push(`<use fill-rule="evenodd" transform="translate(0,0)" xlink:href="#point-${options.suffix}"/>`);
+    parts.push(`<use fill-rule="evenodd" transform="translate(${pointPosition},0)" xlink:href="#point-${options.suffix}"/>`);
+    parts.push(`<use fill-rule="evenodd" transform="translate(0,${pointPosition})" xlink:href="#point-${options.suffix}"/>`);
+    if (options.isShowLogo) if (options.logoData) parts.push(`
+        <image
+          preserveAspectRatio="xMidYMid slice" clip-path="url(#logo-mask-${options.suffix})"
+          style="width: 750px; height: 750px;" width="750" height="750"
+          transform="translate(${position},${position}) ${scale}"
+          xlink:href="${options.logoData}"
+        />
+      `);
+    else parts.push(`
+        <use style="width: 750px; height: 750px;" width="750" height="750"
+          fill="none"
+          fill-rule="evenodd"
+          transform="translate(${position},${position}) ${scale}" xlink:href="#vk_logo-${options.suffix}"
+        />
+      `);
+    const backgroundSize = 99 * qrCode.size;
+    let qrBackground = '';
+    let qrTransform = 'translate(0,0)';
+    if (options.isShowBackground) {
+        const qrScale = (options.qrSize - 40) / options.qrSize;
+        const padding = backgroundSize / options.qrSize * 21;
+        const radius = Math.ceil(backgroundSize / (options.qrSize / 36));
+        qrBackground = `
+      <rect
+        x="0"
+        width="${backgroundSize}"
+        height="${backgroundSize}"
+        rx="${radius}"
+        fill="${options.backgroundColor}"
+      />`;
+        qrTransform = `translate(${padding}, ${padding}) scale(${qrScale})`;
+    }
+    const oneSide = `M0,0 L66,0 C${_84_7},-3.44940413e-15 ${_100},15.2223185 ${_100},34 L${_100},66 C${_100},${_84_7} \
+${_84_7},${_100} 66,${_100} L0,${_100} L0,0 Z`;
+    const twoSides = `M0,0 L${_100},0 L${_100},66 C${_100},${_84_7} ${_84_7},${_100} 66,${_100} L0,${_100} L0,0 Z`;
+    return `
+  <svg
+    version="1.1"
+    viewBox="0 0 ${backgroundSize} ${backgroundSize}"
+    width="${options.qrSize}px"
+    height="${options.qrSize}px"
+    ${options.className ? `class="${options.className}"` : ''}
+    xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+  >
+    <defs>
+      <rect id="rect-${options.suffix}" width="100" height="100" fill="${options.foregroundColor}"/>
+      <path
+        id="empty-${options.suffix}"
+        d="M0,${_28_6}v${_42_9}C0,${_87_3},${_12_8},${_100},${_28_6},${_100}h${_42_9}c${_15_9},0,${_28_6}-${_12_8},\
+${_28_6}-${_28_6}V${_28_6}C${_100},${_12_7},${_87_2},0,${_71_4},0H${_28_6} C${_12_8},0,0,${_12_8},0,${_28_6}z"
+        fill="${options.foregroundColor}"
+      />
+      <path id="b-${options.suffix}" d="${oneSide}" transform="rotate(-90 50 50)" fill="${options.foregroundColor}"/>
+      <path id="r-${options.suffix}" d="${oneSide}" transform="rotate(-180 50 50)" fill="${options.foregroundColor}"/>
+      <path id="l-${options.suffix}" d="${oneSide}" fill="${options.foregroundColor}"/>
+      <path id="t-${options.suffix}" d="${oneSide}" transform="rotate(90 50 50)" fill="${options.foregroundColor}"/>
+      <path id="l-${options.suffix}" d="${twoSides}" transform="rotate(-90 50 50)" fill="${options.foregroundColor}"/>
+      <path id="lt-${options.suffix}" d="${twoSides}" fill="${options.foregroundColor}"/>
+      <path id="lb-${options.suffix}" d="${twoSides}" transform="rotate(-90 50 50)" fill="${options.foregroundColor}"/>
+      <path id="rb-${options.suffix}" d="${twoSides}" transform="rotate(-180 50 50)" fill="${options.foregroundColor}"/>
+      <path id="rt-${options.suffix}" d="${twoSides}" transform="rotate(90 50 50)" fill="${options.foregroundColor}"/>
+      <path
+        id="n_lt-${options.suffix}"
+        d="M${_30_5},${_2}V0H0v${_30_5}h${_2}C${_2},${_14_7},${_14_8},${_2},${_30_5},${_2}z"
+        fill="${options.foregroundColor}"
+      />
+      <path
+        id="n_lb-${options.suffix}"
+        d="M${_2},${_69_5}H0V${_100}h${_30_5}v-${_2}C${_14_7},${_98},${_2},${_85_2},${_2},${_69_5}z"
+        fill="${options.foregroundColor}"
+      />
+      <path
+        id="n_rt-${options.suffix}"
+        d="M${_98},${_30_5}h${_2}V0H${_69_5}v${_2}C${_85_3},${_2},${_98},${_14_8},${_98},${_30_5}z"
+        fill="${options.foregroundColor}"
+      />
+      <path id="n_rb-${options.suffix}"
+        d="M${_69_5},${_98}v${_2}H${_100}V${_69_5}h-${_2}C${_98},${_85_3},${_85_2},${_98},${_69_5},${_98}z"
+        fill="${options.foregroundColor}"
+      />
+      <path
+        id="point-${options.suffix}"
+        fill="${options.foregroundColor}"
+        d="M600.001786,457.329333 L600.001786,242.658167 C600.001786,147.372368 587.039517,124.122784 \
+581.464617,118.535383 C575.877216,112.960483 552.627632,99.9982143 457.329333,99.9982143 \
+L242.670667,99.9982143 C147.372368,99.9982143 124.122784,112.960483 118.547883,118.535383 \
+C112.972983,124.122784 99.9982143,147.372368 99.9982143,242.658167 L99.9982143,457.329333 \
+C99.9982143,552.627632 112.972983,575.877216 118.547883,581.464617 C124.122784,587.027017 \
+147.372368,600.001786 242.670667,600.001786 L457.329333,600.001786 C552.627632,600.001786 \
+575.877216,587.027017 581.464617,581.464617 C587.039517,575.877216 600.001786,552.627632 \
+600.001786,457.329333 Z M457.329333,0 C653.338333,0 700,46.6616668 700,242.658167 C700,438.667167 \
+700,261.332833 700,457.329333 C700,653.338333 653.338333,700 457.329333,700 C261.332833,700 438.667167,700 \
+242.670667,700 C46.6616668,700 0,653.338333 0,457.329333 C0,261.332833 0,352.118712 0,242.658167 \
+C0,46.6616668 46.6616668,0 242.670667,0 C438.667167,0 261.332833,0 457.329333,0 Z M395.996667,200 \
+C480.004166,200 500,220.008332 500,303.990835 C500,387.998334 500,312.001666 500,395.996667 \
+C500,479.991668 480.004166,500 395.996667,500 C312.001666,500 387.998334,500 304.003333,500 C220.008332,500 \
+200,479.991668 200,395.996667 C200,312.001666 200,350.906061 200,303.990835 C200,220.008332 220.008332,200 \
+304.003333,200 C387.998334,200 312.001666,200 395.996667,200 Z"
+      />
+      <g id="vk_logo-${options.suffix}">
+        <path
+          fill="${options.logoColor}"
+          d="M83.3334 363.333C83.3334 231.34 83.3334 165.343 124.338 124.338C165.343 83.3333 231.34 \
+             83.3333 363.333 83.3333H386.667C518.66 83.3333 584.657 83.3333 625.662 124.338C666.667 165.343 \
+             666.667 231.34 666.667 363.333V386.667C666.667 518.66 666.667 584.657 625.662 625.662C584.657 \
+             666.667 518.66 666.667 386.667 666.667H363.333C231.34 666.667 165.343 666.667 124.338 625.662C83.3334 \
+             584.657 83.3334 518.66 83.3334 386.667V363.333Z"
+        />
+        <path
+          fill="#FFF"
+          d="M394.907 508.681C263.293 508.681 183.442 417.365 180.313 265.625H246.972C249.05 377.09 \
+             299.763 424.323 338.638 434.036V265.625H402.519V361.82C440.016 357.664 479.264 313.909 \
+             492.456 265.625H555.333C545.27 325 502.543 368.754 472.353 386.803C502.566 401.395 551.177 \
+             439.593 569.926 508.681H500.815C486.222 462.498 450.476 426.728 402.542 421.872V508.681H394.907Z"
+        />
+      </g>
+      <clipPath id="logo-mask-${options.suffix}">
+        <rect x="0" y="0" width="750" height="750" />
+      </clipPath>
+    </defs>
+
+    ${qrBackground}
+
+    <g transform="${qrTransform}">
+      ${parts.join('\n')}
+    </g>
+  </svg>`;
+};
+class QrCode {
+    static encodeText(text, ecl) {
+        const segs = QrSegment.makeSegments(text);
+        return QrCode.encodeSegments(segs, ecl);
+    }
+    static encodeBinary(data, ecl) {
+        const seg = QrSegment.makeBytes(data);
+        return QrCode.encodeSegments([
+            seg
+        ], ecl);
+    }
+    static encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
+        if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION) || mask < -1 || mask > 7) throw 'Invalid value';
+        let version;
+        let dataUsedBits;
+        for(version = minVersion;; version++){
+            const dataCapacityBits = 8 * QrCode.getNumDataCodewords(version, ecl);
+            const usedBits = QrSegment.getTotalBits(segs, version);
+            if (usedBits <= dataCapacityBits) {
+                dataUsedBits = usedBits;
+                break;
+            }
+            if (version >= maxVersion) throw 'Data too long';
+        }
+        for (const newEcl of [
+            QrCodeEcc.MEDIUM,
+            QrCodeEcc.QUARTILE,
+            QrCodeEcc.HIGH
+        ])if (boostEcl && dataUsedBits <= 8 * QrCode.getNumDataCodewords(version, newEcl)) ecl = newEcl;
+        const bb = new BitBuffer();
+        for (const seg of segs){
+            bb.appendBits(seg.mode.modeBits, 4);
+            bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version));
+            for (const b of seg.getData())bb.array.push(b);
+        }
+        if (bb.array.length !== dataUsedBits) throw 'Assertion error';
+        const dataCapacityBits = 8 * QrCode.getNumDataCodewords(version, ecl);
+        if (bb.array.length > dataCapacityBits) throw 'Assertion error';
+        bb.appendBits(0, Math.min(4, dataCapacityBits - bb.array.length));
+        bb.appendBits(0, (8 - bb.array.length % 8) % 8);
+        if (bb.array.length % 8 !== 0) throw 'Assertion error';
+        for(let padByte = 0xec; bb.array.length < dataCapacityBits; padByte ^= 253)bb.appendBits(padByte, 8);
+        const dataCodewords = [];
+        while(8 * dataCodewords.length < bb.array.length)dataCodewords.push(0);
+        bb.array.forEach((b, i)=>{
+            dataCodewords[i >>> 3] |= b << 7 - (7 & i);
+        });
+        return new QrCode(version, ecl, dataCodewords, mask);
+    }
+    getModule(x, y) {
+        return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
+    }
+    toSvgString(border) {
+        if (border < 0) throw 'Border must be non-negative';
+        const parts = [];
+        for(let y = 0; y < this.size; y++)for(let x = 0; x < this.size; x++)if (this.getModule(x, y)) parts.push(`M${x + border},${y + border}h1v1h-1z`);
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 ${this.size + 2 * border} ${this.size + 2 * border}" stroke="none">
+	<rect width="100%" height="100%" fill="#FFFFFF"/>
+	<path d="${parts.join(' ')}" fill="#000000"/>
+</svg>
+`;
+    }
+    drawFunctionPatterns() {
+        for(let i = 0; i < this.size; i++){
+            this.setFunctionModule(6, i, i % 2 === 0);
+            this.setFunctionModule(i, 6, i % 2 === 0);
+        }
+        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.errorCorrectionLevel.formatBits << 3 | mask;
+        let rem = data;
+        for(let i = 0; i < 10; i++)rem = rem << 1 ^ (rem >>> 9) * 0x537;
+        const bits = (data << 10 | rem) ^ 0x5412;
+        if (bits >>> 15 !== 0) throw 'Assertion error';
+        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) * 0x1f25;
+        const bits = this.version << 12 | rem;
+        if (bits >>> 18 !== 0) throw 'Assertion error';
+        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 (0 <= xx && xx < this.size && 0 <= yy && yy < this.size) this.setFunctionModule(xx, yy, 2 !== dist && 4 !== dist);
+        }
+    }
+    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)));
+    }
+    setFunctionModule(x, y, isBlack) {
+        this.modules[y][x] = isBlack;
+        this.isFunction[y][x] = true;
+    }
+    addEccAndInterleave(data) {
+        const ver = this.version;
+        const ecl = this.errorCorrectionLevel;
+        if (data.length !== QrCode.getNumDataCodewords(ver, ecl)) throw 'Invalid argument';
+        const numBlocks = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+        const blockEccLen = QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
+        const rawCodewords = Math.floor(QrCode.getNumRawDataModules(ver) / 8);
+        const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+        const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+        const blocks = [];
+        const rs = new ReedSolomonGenerator(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 = rs.getRemainder(dat);
+            if (i < numShortBlocks) dat.push(0);
+            blocks.push(dat.concat(ecc));
+        }
+        const result = [];
+        for(let i = 0; i < blocks[0].length; i++)for(let j = 0; j < blocks.length; j++)if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(blocks[j][i]);
+        if (result.length !== rawCodewords) throw 'Assertion error';
+        return result;
+    }
+    drawCodewords(data) {
+        if (data.length !== Math.floor(QrCode.getNumRawDataModules(this.version) / 8)) throw '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.isFunction[y][x] && i < 8 * data.length) {
+                    this.modules[y][x] = getBit(data[i >>> 3], 7 - (7 & i));
+                    i++;
+                }
+            }
+        }
+        if (i !== 8 * data.length) throw 'Assertion error';
+    }
+    applyMask(mask) {
+        if (mask < 0 || mask > 7) throw '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 'Assertion error';
+            }
+            if (!this.isFunction[y][x] && invert) this.modules[y][x] = !this.modules[y][x];
+        }
+    }
+    getPenaltyScore() {
+        let result = 0;
+        for(let y = 0; y < this.size; y++){
+            const runHistory = [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+            ];
+            let color = false;
+            let runX = 0;
+            for(let x = 0; x < this.size; x++)if (this.modules[y][x] === color) {
+                runX++;
+                if (5 === runX) result += QrCode.PENALTY_N1;
+                else if (runX > 5) result++;
+            } else {
+                QrCode.addRunToHistory(runX, runHistory);
+                if (!color && QrCode.hasFinderLikePattern(runHistory)) result += QrCode.PENALTY_N3;
+                color = this.modules[y][x];
+                runX = 1;
+            }
+            QrCode.addRunToHistory(runX, runHistory);
+            if (color) QrCode.addRunToHistory(0, runHistory);
+            if (QrCode.hasFinderLikePattern(runHistory)) result += QrCode.PENALTY_N3;
+        }
+        for(let x = 0; x < this.size; x++){
+            const runHistory = [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+            ];
+            let color = false;
+            let runY = 0;
+            for(let y = 0; y < this.size; y++)if (this.modules[y][x] === color) {
+                runY++;
+                if (5 === runY) result += QrCode.PENALTY_N1;
+                else if (runY > 5) result++;
+            } else {
+                QrCode.addRunToHistory(runY, runHistory);
+                if (!color && QrCode.hasFinderLikePattern(runHistory)) result += QrCode.PENALTY_N3;
+                color = this.modules[y][x];
+                runY = 1;
+            }
+            QrCode.addRunToHistory(runY, runHistory);
+            if (color) QrCode.addRunToHistory(0, runHistory);
+            if (QrCode.hasFinderLikePattern(runHistory)) result += QrCode.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 += QrCode.PENALTY_N2;
+        }
+        let black = 0;
+        for (const row of this.modules)for (const color of row)if (color) black++;
+        const total = this.size * this.size;
+        const k = Math.ceil(Math.abs(20 * black - 10 * total) / total) - 1;
+        result += k * QrCode.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((this.size - 13) / (2 * numAlign - 2));
+            const result = [
+                6
+            ];
+            for(let pos = this.size - 7; result.length < numAlign; pos -= step)result.splice(1, 0, pos);
+            return result;
+        }
+    }
+    static getNumRawDataModules(ver) {
+        if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION) throw '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;
+    }
+    static getNumDataCodewords(ver, ecl) {
+        return Math.floor(QrCode.getNumRawDataModules(ver) / 8) - QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] * QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+    }
+    static addRunToHistory(run, history) {
+        history.pop();
+        history.unshift(run);
+    }
+    static hasFinderLikePattern(runHistory) {
+        const n = runHistory[1];
+        return n > 0 && runHistory[2] === n && runHistory[4] === n && runHistory[5] === n && runHistory[3] === 3 * n && Math.max(runHistory[0], runHistory[6]) >= 4 * n;
+    }
+    constructor(version, errorCorrectionLevel, dataCodewords, mask){
+        _define_property__(this, "size", void 0);
+        _define_property__(this, "modules", []);
+        _define_property__(this, "isFunction", []);
+        _define_property__(this, "version", void 0);
+        _define_property__(this, "errorCorrectionLevel", void 0);
+        _define_property__(this, "mask", void 0);
+        if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION) throw 'Version value out of range';
+        if (mask < -1 || mask > 7) throw 'Mask value out of range';
+        this.version = version;
+        this.errorCorrectionLevel = errorCorrectionLevel;
+        this.size = 4 * version + 17;
+        const row = [];
+        for(let i = 0; i < this.size; i++)row.push(false);
+        for(let i = 0; i < this.size; i++){
+            this.modules.push(row.slice());
+            this.isFunction.push(row.slice());
+        }
+        this.drawFunctionPatterns();
+        const allCodewords = this.addEccAndInterleave(dataCodewords);
+        this.drawCodewords(allCodewords);
+        if (-1 === mask) {
+            let minPenalty = 1000000000;
+            for(let i = 0; i < 8; i++){
+                this.applyMask(i);
+                this.drawFormatBits(i);
+                const penalty = this.getPenaltyScore();
+                if (penalty < minPenalty) {
+                    mask = i;
+                    minPenalty = penalty;
+                }
+                this.applyMask(i);
+            }
+        }
+        if (mask < 0 || mask > 7) throw 'Assertion error';
+        this.mask = mask;
+        this.applyMask(mask);
+        this.drawFormatBits(mask);
+        this.isFunction = [];
+    }
+}
+_define_property__(QrCode, "MIN_VERSION", 1);
+_define_property__(QrCode, "MAX_VERSION", 40);
+_define_property__(QrCode, "PENALTY_N1", 3);
+_define_property__(QrCode, "PENALTY_N2", 3);
+_define_property__(QrCode, "PENALTY_N3", 40);
+_define_property__(QrCode, "PENALTY_N4", 10);
+_define_property__(QrCode, "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
+    ]
+]);
+_define_property__(QrCode, "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
+    ]
+]);
+function getBit(x, i) {
+    return (x >>> i & 1) !== 0;
+}
+class QrSegment {
+    static makeBytes(data) {
+        const bb = new BitBuffer();
+        for (const b of data)bb.appendBits(b, 8);
+        return new QrSegment(QrSegmentMode.BYTE, data.length, bb.array);
+    }
+    static makeNumeric(digits) {
+        if (!QrSegment.NUMERIC_REGEX.test(digits)) throw 'String contains non-numeric characters';
+        const bb = new BitBuffer();
+        for(let i = 0; i < digits.length;){
+            const n = Math.min(digits.length - i, 3);
+            bb.appendBits(parseInt(digits.substr(i, n), 10), 3 * n + 1);
+            i += n;
+        }
+        return new QrSegment(QrSegmentMode.NUMERIC, digits.length, bb.array);
+    }
+    static makeAlphanumeric(text) {
+        if (!QrSegment.ALPHANUMERIC_REGEX.test(text)) throw 'String contains unencodable characters in alphanumeric mode';
+        const bb = new BitBuffer();
+        let i;
+        for(i = 0; i + 2 <= text.length; i += 2){
+            let temp = 45 * QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i));
+            temp += QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+            bb.appendBits(temp, 11);
+        }
+        if (i < text.length) bb.appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6);
+        return new QrSegment(QrSegmentMode.ALPHANUMERIC, text.length, bb.array);
+    }
+    static makeSegments(text) {
+        if ('' === text) return [];
+        if (QrSegment.NUMERIC_REGEX.test(text)) return [
+            QrSegment.makeNumeric(text)
+        ];
+        if (QrSegment.ALPHANUMERIC_REGEX.test(text)) return [
+            QrSegment.makeAlphanumeric(text)
+        ];
+        return [
+            QrSegment.makeBytes(QrSegment.toUtf8ByteArray(text))
+        ];
+    }
+    static makeEci(assignVal) {
+        const bb = new BitBuffer();
+        if (assignVal < 0) throw 'ECI assignment value out of range';
+        if (assignVal < 128) bb.appendBits(assignVal, 8);
+        else if (assignVal < 16384) {
+            bb.appendBits(2, 2);
+            bb.appendBits(assignVal, 14);
+        } else if (assignVal < 1000000) {
+            bb.appendBits(6, 3);
+            bb.appendBits(assignVal, 21);
+        } else throw 'ECI assignment value out of range';
+        return new QrSegment(QrSegmentMode.ECI, 0, bb.array);
+    }
+    getData() {
+        return this.bitData.slice();
+    }
+    static getTotalBits(segs, version) {
+        let result = 0;
+        for (const seg of segs){
+            const ccbits = seg.mode.numCharCountBits(version);
+            if (seg.numChars >= 1 << ccbits) return 1 / 0;
+            result += 4 + ccbits + seg.bitData.length;
+        }
+        return result;
+    }
+    static 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(parseInt(str.substr(i + 1, 2), 16));
+            i += 2;
+        }
+        return result;
+    }
+    constructor(mode, numChars, bitData){
+        _define_property__(this, "mode", void 0);
+        _define_property__(this, "numChars", void 0);
+        _define_property__(this, "bitData", void 0);
+        if (numChars < 0) throw 'Invalid argument';
+        this.mode = mode;
+        this.numChars = numChars;
+        this.bitData = bitData.slice();
+    }
+}
+_define_property__(QrSegment, "NUMERIC_REGEX", /^[0-9]*$/);
+_define_property__(QrSegment, "ALPHANUMERIC_REGEX", /^[A-Z0-9 $%*+./:-]*$/);
+_define_property__(QrSegment, "ALPHANUMERIC_CHARSET", '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:');
+class ReedSolomonGenerator {
+    getRemainder(data) {
+        const result = this.coefficients.map((_)=>0);
+        for (const b of data){
+            const factor = b ^ result.shift();
+            result.push(0);
+            this.coefficients.forEach((coef, i)=>{
+                result[i] ^= ReedSolomonGenerator.multiply(coef, factor);
+            });
+        }
+        return result;
+    }
+    static multiply(x, y) {
+        if (x >>> 8 !== 0 || y >>> 8 !== 0) throw 'Byte out of range';
+        let z = 0;
+        for(let i = 7; i >= 0; i--){
+            z = z << 1 ^ (z >>> 7) * 0x11d;
+            z ^= (y >>> i & 1) * x;
+        }
+        if (z >>> 8 !== 0) throw 'Assertion error';
+        return z;
+    }
+    constructor(degree){
+        _define_property__(this, "coefficients", []);
+        if (degree < 1 || degree > 255) throw 'Degree out of range';
+        const coefs = this.coefficients;
+        for(let i = 0; i < degree - 1; i++)coefs.push(0);
+        coefs.push(1);
+        let root = 1;
+        for(let i = 0; i < degree; i++){
+            for(let j = 0; j < coefs.length; j++){
+                coefs[j] = ReedSolomonGenerator.multiply(coefs[j], root);
+                if (j + 1 < coefs.length) coefs[j] ^= coefs[j + 1];
+            }
+            root = ReedSolomonGenerator.multiply(root, 0x02);
+        }
+    }
+}
+class BitBuffer {
+    appendBits(val, len) {
+        if (len < 0 || len > 31 || val >>> len !== 0) throw 'Value out of range';
+        for(let i = len - 1; i >= 0; i--)this.array.push(val >>> i & 1);
+    }
+    constructor(){
+        _define_property__(this, "array", []);
+    }
+}
+class QrCodeEcc {
+    constructor(ordinal, formatBits){
+        _define_property__(this, "ordinal", void 0);
+        _define_property__(this, "formatBits", void 0);
+        this.ordinal = ordinal;
+        this.formatBits = formatBits;
+    }
+}
+_define_property__(QrCodeEcc, "LOW", new QrCodeEcc(0, 1));
+_define_property__(QrCodeEcc, "MEDIUM", new QrCodeEcc(1, 0));
+_define_property__(QrCodeEcc, "QUARTILE", new QrCodeEcc(2, 3));
+_define_property__(QrCodeEcc, "HIGH", new QrCodeEcc(3, 2));
+class QrSegmentMode {
+    numCharCountBits(ver) {
+        return this.numBitsCharCount[Math.floor((ver + 7) / 17)];
+    }
+    constructor(modeBits, numBitsCharCount){
+        _define_property__(this, "modeBits", void 0);
+        _define_property__(this, "numBitsCharCount", void 0);
+        this.modeBits = modeBits;
+        this.numBitsCharCount = numBitsCharCount;
+    }
+}
+_define_property__(QrSegmentMode, "NUMERIC", new QrSegmentMode(0x1, [
+    10,
+    12,
+    14
+]));
+_define_property__(QrSegmentMode, "ALPHANUMERIC", new QrSegmentMode(0x2, [
+    9,
+    11,
+    13
+]));
+_define_property__(QrSegmentMode, "BYTE", new QrSegmentMode(0x4, [
+    8,
+    16,
+    16
+]));
+_define_property__(QrSegmentMode, "KANJI", new QrSegmentMode(0x8, [
+    8,
+    10,
+    12
+]));
+_define_property__(QrSegmentMode, "ECI", new QrSegmentMode(0x7, [
+    0,
+    0,
+    0
+]));
+const DEFAULT_SIZE = 128;
+const BACKGROUND_COLOR_DEFAULT = '#ffffff';
+const FOREGROUND_COLOR_DEFAULT = '#000000';
+const LOGO_COLOR_DEFAULT = '#07f';
+function createQR(text, qrSizeOrOptions, classNameLegacy, legacyOptions) {
+    if ('string' != typeof text) throw new TypeError('Enter text for encoding');
+    const options = {
+        ...'object' == typeof qrSizeOrOptions && null !== qrSizeOrOptions ? qrSizeOrOptions : {},
+        ...'object' == typeof legacyOptions && null !== legacyOptions ? legacyOptions : {},
+        qrSize: 'object' == typeof qrSizeOrOptions && null !== qrSizeOrOptions && 'number' == typeof qrSizeOrOptions.qrSize ? qrSizeOrOptions.qrSize : qrSizeOrOptions,
+        className: 'object' == typeof qrSizeOrOptions && null !== qrSizeOrOptions && 'string' == typeof qrSizeOrOptions.className ? qrSizeOrOptions.className : classNameLegacy
+    };
+    const eccLevels = [
+        QrCodeEcc.LOW,
+        QrCodeEcc.MEDIUM,
+        QrCodeEcc.QUARTILE,
+        QrCodeEcc.HIGH
+    ];
+    const fallbackOptions = {
+        qrSize: 'number' == typeof options.qrSize ? options.qrSize : DEFAULT_SIZE,
+        className: 'string' == typeof options.className ? options.className : classNameLegacy || '',
+        isShowLogo: !!options.isShowLogo || false,
+        isShowBackground: !!options.isShowBackground || false,
+        foregroundColor: 'string' == typeof options.foregroundColor ? options.foregroundColor : FOREGROUND_COLOR_DEFAULT,
+        backgroundColor: 'string' == typeof options.backgroundColor ? options.backgroundColor : BACKGROUND_COLOR_DEFAULT,
+        logoColor: 'string' == typeof options.logoColor ? options.logoColor : LOGO_COLOR_DEFAULT,
+        suffix: options.suffix ? options.suffix.toString() : '0',
+        logoData: 'string' == typeof options.logoData ? options.logoData : null,
+        ecc: 'number' == typeof options.ecc && eccLevels[options.ecc] ? options.ecc : 3,
+        incTileSize: 'number' == typeof options.incTileSize ? options.incTileSize : 96
+    };
+    const segments = QrSegment.makeSegments(text);
+    const qrCode = QrCode.encodeSegments(segments, eccLevels[fallbackOptions.ecc], 1, 40, -1, true);
+    const svgCode = convertSegmentsToSvgString(qrCode, fallbackOptions);
+    return svgCode;
+}
+export { createQR };
+
+//# sourceMappingURL=index.js.map