@vkontakte/vk-qr 2.1.1 → 3.1.0

package/dist/index.js

@@ -0,0 +1,1311 @@
+function isFinderPattern(figure, size) {
+    const { x, y, pixels } = figure;
+    const width = pixels[0]?.length ?? 0;
+    const height = pixels.length;
+    const right = x + width - 1;
+    const bottom = y + height - 1;
+    const finderRegions = [
+        [
+            0,
+            0,
+            6,
+            6
+        ],
+        [
+            size - 7,
+            0,
+            size - 1,
+            6
+        ],
+        [
+            0,
+            size - 7,
+            6,
+            size - 1
+        ]
+    ];
+    for (const [rx1, ry1, rx2, ry2] of finderRegions)if (x >= rx1 && y >= ry1 && right <= rx2 && bottom <= ry2) return true;
+    return false;
+}
+function extractFigures(image) {
+    const height = image.length;
+    const width = image[0]?.length ?? 0;
+    const visited = Array.from({
+        length: height
+    }, ()=>Array(width).fill(false));
+    const figures = [];
+    const directions = [
+        [
+            0,
+            -1
+        ],
+        [
+            1,
+            0
+        ],
+        [
+            0,
+            1
+        ],
+        [
+            -1,
+            0
+        ]
+    ];
+    function isInside(x, y) {
+        return y >= 0 && y < height && x >= 0 && x < width;
+    }
+    for(let y = 0; y < height; y++)for(let x = 0; x < width; x++){
+        if (visited[y][x]) continue;
+        if (!image[y][x]) continue;
+        const cells = [
+            [
+                x,
+                y
+            ]
+        ];
+        visited[y][x] = true;
+        let minX = x;
+        let maxX = x;
+        let minY = y;
+        let maxY = y;
+        for(let head = 0; head < cells.length; head++){
+            const [cx, cy] = cells[head];
+            minX = Math.min(minX, cx);
+            maxX = Math.max(maxX, cx);
+            minY = Math.min(minY, cy);
+            maxY = Math.max(maxY, cy);
+            for (const [dx, dy] of directions){
+                const nx = cx + dx;
+                const ny = cy + dy;
+                if (isInside(nx, ny)) {
+                    if (!visited[ny][nx]) {
+                        if (image[ny][nx]) {
+                            visited[ny][nx] = true;
+                            cells.push([
+                                nx,
+                                ny
+                            ]);
+                        }
+                    }
+                }
+            }
+        }
+        const figureWidth = maxX - minX + 1;
+        const figureHeight = maxY - minY + 1;
+        const pixels = Array.from({
+            length: figureHeight
+        }, ()=>Array(figureWidth).fill(false));
+        for (const [cellX, cellY] of cells)pixels[cellY - minY][cellX - minX] = true;
+        figures.push({
+            x: minX,
+            y: minY,
+            pixels
+        });
+    }
+    return figures;
+}
+function figureToSvgPath(figure, options = {}) {
+    const pixelSize = options.pixelSize ?? 100;
+    const radius = options.radius ?? 35;
+    const contours = buildContours(getBoundaryEdges(figure, pixelSize));
+    const cornerRadius = createCornerRadiusResolver(figure, pixelSize, radius);
+    return contours.map((contour)=>contourToRoundedPath(contour, cornerRadius)).join(' ');
+}
+function hasPixel(pixels, x, y) {
+    return pixels[y]?.[x] ?? false;
+}
+function getBoundaryEdges(figure, pixelSize) {
+    const pixels = figure.pixels;
+    const height = pixels.length;
+    const width = pixels[0]?.length ?? 0;
+    const edges = [];
+    function px(x) {
+        return (figure.x + x) * pixelSize;
+    }
+    function py(y) {
+        return (figure.y + y) * pixelSize;
+    }
+    for(let y = 0; y < height; y++)for(let x = 0; x < width; x++){
+        if (!pixels[y][x]) continue;
+        const left = px(x);
+        const right = px(x + 1);
+        const top = py(y);
+        const bottom = py(y + 1);
+        if (!hasPixel(pixels, x, y - 1)) edges.push({
+            from: {
+                x: left,
+                y: top
+            },
+            to: {
+                x: right,
+                y: top
+            }
+        });
+        if (!hasPixel(pixels, x + 1, y)) edges.push({
+            from: {
+                x: right,
+                y: top
+            },
+            to: {
+                x: right,
+                y: bottom
+            }
+        });
+        if (!hasPixel(pixels, x, y + 1)) edges.push({
+            from: {
+                x: right,
+                y: bottom
+            },
+            to: {
+                x: left,
+                y: bottom
+            }
+        });
+        if (!hasPixel(pixels, x - 1, y)) edges.push({
+            from: {
+                x: left,
+                y: bottom
+            },
+            to: {
+                x: left,
+                y: top
+            }
+        });
+    }
+    return edges;
+}
+function hasFilledCorner(pixels, x, y, dx, dy) {
+    return hasPixel(pixels, x + dx, y) && hasPixel(pixels, x, y + dy) && hasPixel(pixels, x + dx, y + dy);
+}
+function createCornerRadiusResolver(figure, pixelSize, radius) {
+    return (prev, current, next)=>{
+        if (getTurn(prev, current, next) < 0) {
+            const x = Math.round(Math.min(prev.x, current.x, next.x) / pixelSize) - figure.x;
+            const y = Math.round(Math.min(prev.y, current.y, next.y) / pixelSize) - figure.y;
+            const topLeft = hasFilledCorner(figure.pixels, x, y, -1, -1);
+            const bottomLeft = hasFilledCorner(figure.pixels, x, y, -1, 1);
+            const topRight = hasFilledCorner(figure.pixels, x, y, 1, -1);
+            const bottomRight = hasFilledCorner(figure.pixels, x, y, 1, 1);
+            const roundsBottomRight = bottomRight && (!topRight || bottomLeft && !topLeft);
+            return roundsBottomRight && current.x === (figure.x + (x + 1)) * pixelSize && current.y === (figure.y + (y + 1)) * pixelSize ? radius : 0;
+        }
+        return radius;
+    };
+}
+function buildContours(edges) {
+    const edgeMap = new Map();
+    for (const edge of edges){
+        const key = pointKey(edge.from);
+        const list = edgeMap.get(key);
+        if (list) list.push(edge.to);
+        else edgeMap.set(key, [
+            edge.to
+        ]);
+    }
+    const contours = [];
+    while(true){
+        const startKey = edgeMap.keys().next().value;
+        if (void 0 === startKey) break;
+        const [x, y] = startKey.split(',').map(Number);
+        const start = {
+            x,
+            y
+        };
+        const contour = [
+            start
+        ];
+        let current = start;
+        while(true){
+            const candidates = edgeMap.get(pointKey(current));
+            if (!candidates || 0 === candidates.length) throw new Error('Broken contour: edge chain is not closed');
+            let nextIndex = 0;
+            if (candidates.length > 1 && contour.length > 1) {
+                const prev = contour[contour.length - 2];
+                const rightTurn = candidates.findIndex((candidate)=>getTurn(prev, current, candidate) > 0);
+                if (-1 !== rightTurn) nextIndex = rightTurn;
+            }
+            const [next] = candidates.splice(nextIndex, 1);
+            if (0 === candidates.length) edgeMap.delete(pointKey(current));
+            if (samePoint(next, start)) break;
+            contour.push(next);
+            current = next;
+        }
+        contours.push(contour);
+    }
+    return contours;
+}
+function contourToRoundedPath(contour, cornerRadius) {
+    const n = contour.length;
+    if (0 === n) return '';
+    const commands = [];
+    for(let i = 0; i < n; i++){
+        const prev = contour[(i - 1 + n) % n];
+        const current = contour[i];
+        const next = contour[(i + 1) % n];
+        const incomingLength = distance(current, prev);
+        const outgoingLength = distance(current, next);
+        const r = Math.min(cornerRadius(prev, current, next), incomingLength / 2, outgoingLength / 2);
+        const beforeCorner = moveTowards(current, prev, r);
+        const afterCorner = moveTowards(current, next, r);
+        commands.push(`${0 === i ? 'M' : 'L'} ${beforeCorner.x} ${beforeCorner.y}`);
+        if (r > 0) commands.push(`Q ${current.x} ${current.y} ${afterCorner.x} ${afterCorner.y}`);
+    }
+    commands.push('Z');
+    return commands.join(' ');
+}
+function moveTowards(from, to, distanceValue) {
+    const length = distance(from, to);
+    if (0 === length) return {
+        ...from
+    };
+    const ratio = distanceValue / length;
+    return {
+        x: from.x + (to.x - from.x) * ratio,
+        y: from.y + (to.y - from.y) * ratio
+    };
+}
+function distance(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function pointKey(point) {
+    return `${point.x},${point.y}`;
+}
+function samePoint(a, b) {
+    return a.x === b.x && a.y === b.y;
+}
+function getTurn(prev, current, next) {
+    return (current.x - prev.x) * (next.y - current.y) - (current.y - prev.y) * (next.x - current.x);
+}
+const INC_TILE_SIZE = 100;
+function 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 background = getBackgroundLayout(qrCode.size, options);
+    const parts = renderFinderPatterns(qrCode.size, options);
+    if (options.isShowLogo) parts.push(renderLogo(qrCode.size, options));
+    return `
+  <svg
+    version="1.1"
+    viewBox="${-background.padding} ${-background.padding} ${background.size} ${background.size}"
+    width="${options.qrSize}px"
+    height="${options.qrSize}px"
+    style="display: block"
+    ${options.className ? `class="${options.className}"` : ''}
+    xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+  >
+    ${renderDefinitions(options)}
+
+    ${renderBackground(background, options)}
+
+    <g${background.hideQr ? ' display="none"' : ''}>
+    ${renderModules(qrCode, options)}
+      ${parts.join('\n')}
+    </g>
+
+  </svg>`;
+}
+function getVisibleModules(qrCode, isShowLogo) {
+    if (!isShowLogo) return qrCode.modules;
+    const logoAreaSize = qrCode.size <= 25 ? 7 : 9;
+    const logoAreaStart = (qrCode.size - logoAreaSize) / 2;
+    return qrCode.modules.map((row, y)=>row.map((pixel, x)=>pixel && !(x >= logoAreaStart && x < logoAreaStart + logoAreaSize && y >= logoAreaStart && y < logoAreaStart + logoAreaSize)));
+}
+function renderModules(qrCode, options) {
+    return extractFigures(getVisibleModules(qrCode, options.isShowLogo)).filter((figure)=>!isFinderPattern(figure, qrCode.size)).map((figure)=>`
+      <path
+        d="${figureToSvgPath(figure)}"
+        fill="${options.foregroundColor}"
+        fill-rule="evenodd"
+      />`).join('');
+}
+function renderFinderPatterns(size, options) {
+    const pointPosition = (size - 7) * 100;
+    return [
+        `<use fill-rule="evenodd" transform="translate(0,0)" xlink:href="#point-${options.suffix}"/>`,
+        `<use fill-rule="evenodd" transform="translate(${pointPosition},0)" xlink:href="#point-${options.suffix}"/>`,
+        `<use fill-rule="evenodd" transform="translate(0,${pointPosition})" xlink:href="#point-${options.suffix}"/>`
+    ];
+}
+function renderLogo(size, options) {
+    let scale = '';
+    let position = (size - 21) / 2 * 100 + 700 - 10;
+    if (size <= 25) {
+        scale = 'scale(0.85)';
+        position += 50;
+    }
+    if (!options.logoData) return `
+        <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}"
+        />
+      `;
+    return `
+        <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}"
+        />
+      `;
+}
+function getBackgroundLayout(size, options) {
+    const contentSize = 100 * size;
+    if (!options.isShowBackground) return {
+        size: contentSize,
+        padding: 0,
+        radius: 0,
+        hideQr: false
+    };
+    const frameWidth = Math.min(options.backgroundPadding, options.qrSize / 2);
+    const contentWidth = options.qrSize - 2 * frameWidth;
+    const hideQr = contentWidth <= 0;
+    const backgroundSize = hideQr ? contentSize : contentSize * options.qrSize / contentWidth;
+    const padding = (backgroundSize - contentSize) / 2;
+    const radius = Math.min(options.backgroundRadius, options.qrSize / 2) / options.qrSize * backgroundSize;
+    return {
+        size: backgroundSize,
+        padding,
+        radius,
+        hideQr
+    };
+}
+function renderBackground(layout, options) {
+    if (!options.isShowBackground) return '';
+    const { size, padding, radius } = layout;
+    return `
+      <rect
+        x="${-padding}"
+        y="${-padding}"
+        width="${size}"
+        height="${size}"
+        rx="${radius}"
+        fill="${options.backgroundColor}"
+      />`;
+}
+function renderDefinitions(options) {
+    return `<defs>
+      <g
+        id="point-${options.suffix}"
+        fill="${options.foregroundColor}"
+      >
+        <rect width="300" height="300" x="200" y="200" rx="67" />
+        <rect width="600" height="600" x="50" y="50" rx="134" stroke-width="100" fill="none" stroke="${options.foregroundColor}" />
+      </g>
+      <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>`;
+}
+const QrCodeEcc = {
+    LOW: {
+        ordinal: 0,
+        formatBits: 1
+    },
+    MEDIUM: {
+        ordinal: 1,
+        formatBits: 0
+    },
+    QUARTILE: {
+        ordinal: 2,
+        formatBits: 3
+    },
+    HIGH: {
+        ordinal: 3,
+        formatBits: 2
+    }
+};
+const QrSegmentMode = {
+    NUMERIC: {
+        modeBits: 0x1,
+        numBitsCharCount: [
+            10,
+            12,
+            14
+        ]
+    },
+    ALPHANUMERIC: {
+        modeBits: 0x2,
+        numBitsCharCount: [
+            9,
+            11,
+            13
+        ]
+    },
+    BYTE: {
+        modeBits: 0x4,
+        numBitsCharCount: [
+            8,
+            16,
+            16
+        ]
+    },
+    KANJI: {
+        modeBits: 0x8,
+        numBitsCharCount: [
+            8,
+            10,
+            12
+        ]
+    },
+    ECI: {
+        modeBits: 0x7,
+        numBitsCharCount: [
+            0,
+            0,
+            0
+        ]
+    }
+};
+function numCharCountBits(mode, ver) {
+    return mode.numBitsCharCount[Math.floor((ver + 7) / 17)];
+}
+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 'Invalid value';
+    let version;
+    let dataUsedBits;
+    for(version = minVersion;; version++){
+        const dataCapacityBits = 8 * getNumDataCodewords(version, ecl);
+        const usedBits = getTotalBits(segs, version);
+        if (usedBits <= dataCapacityBits) {
+            dataUsedBits = usedBits;
+            break;
+        }
+        if (version >= maxVersion) throw 'Data too long';
+    }
+    let finalEcl = ecl;
+    for (const newEcl of [
+        QrCodeEcc.MEDIUM,
+        QrCodeEcc.QUARTILE,
+        QrCodeEcc.HIGH
+    ])if (boostEcl && dataUsedBits <= 8 * getNumDataCodewords(version, newEcl)) finalEcl = newEcl;
+    const bb = createBitBuffer();
+    for (const seg of segs){
+        bb.appendBits(seg.mode.modeBits, 4);
+        bb.appendBits(seg.numChars, numCharCountBits(seg.mode, version));
+        for (const b of seg.getData())bb.array.push(b);
+    }
+    if (bb.array.length !== dataUsedBits) throw 'Assertion error';
+    const dataCapacityBits = 8 * getNumDataCodewords(version, finalEcl);
+    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 createQrCode(version, finalEcl, dataCodewords, mask);
+}
+function createQrCode(version, errorCorrectionLevel, dataCodewords, mask) {
+    if (version < MIN_VERSION || version > MAX_VERSION) throw 'Version value out of range';
+    if (mask < -1 || mask > 7) throw 'Mask value out of range';
+    const size = 4 * version + 17;
+    const row = [];
+    for(let i = 0; i < size; i++)row.push(false);
+    const modules = [];
+    const isFunction = [];
+    for(let i = 0; i < size; i++){
+        modules.push(row.slice());
+        isFunction.push(row.slice());
+    }
+    const setFunctionModule = (x, y, isBlack)=>{
+        modules[y][x] = isBlack;
+        isFunction[y][x] = true;
+    };
+    for(let i = 0; i < size; i++){
+        setFunctionModule(6, i, i % 2 === 0);
+        setFunctionModule(i, 6, i % 2 === 0);
+    }
+    const 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 < size && 0 <= yy && yy < size) setFunctionModule(xx, yy, 2 !== dist && 4 !== dist);
+        }
+    };
+    drawFinderPattern(3, 3);
+    drawFinderPattern(size - 4, 3);
+    drawFinderPattern(3, size - 4);
+    const alignPatPos = getAlignmentPatternPositions(version, size);
+    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)) {
+        const drawAlignmentPattern = (x, y)=>{
+            for(let dy = -2; dy <= 2; dy++)for(let dx = -2; dx <= 2; dx++)setFunctionModule(x + dx, y + dy, 1 !== Math.max(Math.abs(dx), Math.abs(dy)));
+        };
+        drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+    }
+    const drawFormatBits = (ecl, msk)=>{
+        const data = ecl.formatBits << 3 | msk;
+        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++)setFunctionModule(8, i, getBit(bits, i));
+        setFunctionModule(8, 7, getBit(bits, 6));
+        setFunctionModule(8, 8, getBit(bits, 7));
+        setFunctionModule(7, 8, getBit(bits, 8));
+        for(let i = 9; i < 15; i++)setFunctionModule(14 - i, 8, getBit(bits, i));
+        for(let i = 0; i < 8; i++)setFunctionModule(size - 1 - i, 8, getBit(bits, i));
+        for(let i = 8; i < 15; i++)setFunctionModule(8, size - 15 + i, getBit(bits, i));
+        setFunctionModule(8, size - 8, true);
+    };
+    drawFormatBits(errorCorrectionLevel, 0);
+    if (version >= 7) {
+        let rem = version;
+        for(let i = 0; i < 12; i++)rem = rem << 1 ^ (rem >>> 11) * 0x1f25;
+        const bits = version << 12 | rem;
+        if (bits >>> 18 !== 0) throw 'Assertion error';
+        for(let i = 0; i < 18; i++){
+            const color = getBit(bits, i);
+            const a = size - 11 + i % 3;
+            const b = Math.floor(i / 3);
+            setFunctionModule(a, b, color);
+            setFunctionModule(b, a, color);
+        }
+    }
+    const allCodewords = addEccAndInterleave(version, errorCorrectionLevel, dataCodewords);
+    if (allCodewords.length !== Math.floor(getNumRawDataModules(version) / 8)) throw 'Invalid argument';
+    let bitIndex = 0;
+    for(let right = size - 1; right >= 1; right -= 2){
+        if (6 === right) right = 5;
+        for(let vert = 0; vert < size; vert++)for(let j = 0; j < 2; j++){
+            const x = right - j;
+            const upward = (right + 1 & 2) === 0;
+            const y = upward ? size - 1 - vert : vert;
+            if (!isFunction[y][x] && bitIndex < 8 * allCodewords.length) {
+                modules[y][x] = getBit(allCodewords[bitIndex >>> 3], 7 - (7 & bitIndex));
+                bitIndex++;
+            }
+        }
+    }
+    if (bitIndex !== 8 * allCodewords.length) throw 'Assertion error';
+    let finalMask = mask;
+    if (-1 === finalMask) {
+        let minPenalty = 1000000000;
+        for(let i = 0; i < 8; i++){
+            applyMask(modules, isFunction, size, i);
+            drawFormatBits(errorCorrectionLevel, i);
+            const penalty = getPenaltyScore(modules, size);
+            if (penalty < minPenalty) {
+                finalMask = i;
+                minPenalty = penalty;
+            }
+            applyMask(modules, isFunction, size, i);
+        }
+    }
+    if (finalMask < 0 || finalMask > 7) throw 'Assertion error';
+    applyMask(modules, isFunction, size, finalMask);
+    {
+        const data = errorCorrectionLevel.formatBits << 3 | finalMask;
+        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++)modules[i][8] = getBit(bits, i);
+        modules[7][8] = getBit(bits, 6);
+        modules[8][8] = getBit(bits, 7);
+        modules[8][7] = getBit(bits, 8);
+        for(let i = 9; i < 15; i++)modules[8][14 - i] = getBit(bits, i);
+        for(let i = 0; i < 8; i++)modules[8][size - 1 - i] = getBit(bits, i);
+        for(let i = 8; i < 15; i++)modules[size - 15 + i][8] = getBit(bits, i);
+        modules[size - 8][8] = true;
+    }
+    return {
+        version,
+        errorCorrectionLevel,
+        size,
+        mask: finalMask,
+        modules
+    };
+}
+function getAlignmentPatternPositions(version, size) {
+    if (1 === version) return [];
+    else {
+        const numAlign = Math.floor(version / 7) + 2;
+        const step = 32 === version ? 26 : 2 * Math.ceil((size - 13) / (2 * numAlign - 2));
+        const result = [
+            6
+        ];
+        for(let pos = size - 7; result.length < numAlign; pos -= step)result.splice(1, 0, pos);
+        return result;
+    }
+}
+function applyMask(modules, isFunction, size, mask) {
+    if (mask < 0 || mask > 7) throw 'Mask value out of range';
+    for(let y = 0; y < size; y++)for(let x = 0; x < 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 (!isFunction[y][x] && invert) modules[y][x] = !modules[y][x];
+    }
+}
+function getPenaltyScore(modules, size) {
+    let result = 0;
+    for(let y = 0; y < size; y++){
+        const runHistory = [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        ];
+        let color = false;
+        let runX = 0;
+        for(let x = 0; x < size; x++)if (modules[y][x] === color) {
+            runX++;
+            if (5 === runX) result += PENALTY_N1;
+            else if (runX > 5) result++;
+        } else {
+            addRunToHistory(runX, runHistory);
+            if (!color && hasFinderLikePattern(runHistory)) result += PENALTY_N3;
+            color = modules[y][x];
+            runX = 1;
+        }
+        addRunToHistory(runX, runHistory);
+        if (color) addRunToHistory(0, runHistory);
+        if (hasFinderLikePattern(runHistory)) result += PENALTY_N3;
+    }
+    for(let x = 0; x < size; x++){
+        const runHistory = [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        ];
+        let color = false;
+        let runY = 0;
+        for(let y = 0; y < size; y++)if (modules[y][x] === color) {
+            runY++;
+            if (5 === runY) result += PENALTY_N1;
+            else if (runY > 5) result++;
+        } else {
+            addRunToHistory(runY, runHistory);
+            if (!color && hasFinderLikePattern(runHistory)) result += PENALTY_N3;
+            color = modules[y][x];
+            runY = 1;
+        }
+        addRunToHistory(runY, runHistory);
+        if (color) addRunToHistory(0, runHistory);
+        if (hasFinderLikePattern(runHistory)) result += PENALTY_N3;
+    }
+    for(let y = 0; y < size - 1; y++)for(let x = 0; x < size - 1; x++){
+        const color = modules[y][x];
+        if (color === modules[y][x + 1] && color === modules[y + 1][x] && color === modules[y + 1][x + 1]) result += PENALTY_N2;
+    }
+    let black = 0;
+    for (const row of modules)for (const color of row)if (color) black++;
+    const total = size * size;
+    const k = Math.ceil(Math.abs(20 * black - 10 * total) / total) - 1;
+    result += k * PENALTY_N4;
+    return result;
+}
+function addRunToHistory(run, history) {
+    history.pop();
+    history.unshift(run);
+}
+function 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;
+}
+function addEccAndInterleave(version, ecl, data) {
+    if (data.length !== getNumDataCodewords(version, ecl)) throw 'Invalid argument';
+    const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][version];
+    const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][version];
+    const rawCodewords = Math.floor(getNumRawDataModules(version) / 8);
+    const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const blocks = [];
+    const rs = createReedSolomonGenerator(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;
+}
+function getNumRawDataModules(ver) {
+    if (ver < MIN_VERSION || ver > 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;
+}
+function getNumDataCodewords(ver, ecl) {
+    return Math.floor(getNumRawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] * NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+}
+function getBit(x, i) {
+    return (x >>> i & 1) !== 0;
+}
+function createQrSegment(mode, numChars, bitData) {
+    if (numChars < 0) throw 'Invalid argument';
+    const data = bitData.slice();
+    return {
+        mode,
+        numChars,
+        getData: ()=>data.slice()
+    };
+}
+function makeBytes(data) {
+    const bb = createBitBuffer();
+    for (const b of data)bb.appendBits(b, 8);
+    return createQrSegment(QrSegmentMode.BYTE, data.length, bb.array);
+}
+function makeNumeric(digits) {
+    if (!NUMERIC_REGEX.test(digits)) throw 'String contains non-numeric characters';
+    const bb = createBitBuffer();
+    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 createQrSegment(QrSegmentMode.NUMERIC, digits.length, bb.array);
+}
+function makeAlphanumeric(text) {
+    if (!ALPHANUMERIC_REGEX.test(text)) throw 'String contains unencodable characters in alphanumeric mode';
+    const bb = createBitBuffer();
+    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));
+        bb.appendBits(temp, 11);
+    }
+    if (i < text.length) bb.appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6);
+    return createQrSegment(QrSegmentMode.ALPHANUMERIC, text.length, bb.array);
+}
+function makeSegments(text) {
+    if ('' === text) return [];
+    else if (NUMERIC_REGEX.test(text)) return [
+        makeNumeric(text)
+    ];
+    else if (ALPHANUMERIC_REGEX.test(text)) return [
+        makeAlphanumeric(text)
+    ];
+    else return [
+        makeBytes(toUtf8ByteArray(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.getData().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(parseInt(str.substr(i + 1, 2), 16));
+        i += 2;
+    }
+    return result;
+}
+function createBitBuffer() {
+    const array = [];
+    return {
+        array,
+        appendBits (val, len) {
+            if (len < 0 || len > 31 || val >>> len !== 0) throw 'Value out of range';
+            for(let i = len - 1; i >= 0; i--)array.push(val >>> i & 1);
+        }
+    };
+}
+function createReedSolomonGenerator(degree) {
+    if (degree < 1 || degree > 255) throw 'Degree out of range';
+    const coefficients = [];
+    for(let i = 0; i < degree - 1; i++)coefficients.push(0);
+    coefficients.push(1);
+    let root = 1;
+    for(let i = 0; i < degree; i++){
+        for(let j = 0; j < coefficients.length; j++){
+            coefficients[j] = rsMultiply(coefficients[j], root);
+            if (j + 1 < coefficients.length) coefficients[j] ^= coefficients[j + 1];
+        }
+        root = rsMultiply(root, 0x02);
+    }
+    return {
+        getRemainder (data) {
+            const result = coefficients.map(()=>0);
+            for (const b of data){
+                const factor = b ^ result.shift();
+                result.push(0);
+                coefficients.forEach((coef, i)=>{
+                    result[i] ^= rsMultiply(coef, factor);
+                });
+            }
+            return result;
+        }
+    };
+}
+function rsMultiply(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;
+}
+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
+    ]
+];
+const NUMERIC_REGEX = /^[0-9]*$/;
+const ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
+const ALPHANUMERIC_CHARSET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+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,
+        backgroundPadding: 'number' == typeof options.backgroundPadding && Number.isFinite(options.backgroundPadding) && options.backgroundPadding >= 0 ? options.backgroundPadding : 20,
+        backgroundRadius: 'number' == typeof options.backgroundRadius && Number.isFinite(options.backgroundRadius) && options.backgroundRadius >= 0 ? options.backgroundRadius : 36,
+        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 : INC_TILE_SIZE
+    };
+    const segments = makeSegments(text);
+    const qrCode = encodeSegments(segments, eccLevels[fallbackOptions.ecc], 1, 40, -1, true);
+    const svgCode = convertSegmentsToSvgString(qrCode, fallbackOptions);
+    return svgCode;
+}
+export { createQR };
+
+//# sourceMappingURL=index.js.map