@vkontakte/vk-qr 3.0.0 → 3.1.0

package/dist/index.js

@@ -1,194 +1,398 @@
-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];
+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;
     }
-    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';
+    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
+                            ]);
+                        }
+                    }
                 }
-            } 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>`);
+        }
+        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;
         }
-        topPadding += TILE_SIZE;
+        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 = (qrCode.size - 3 * QR_BORDER) / 2 * TILE_SIZE + TILE_SIZE * QR_BORDER - 10;
-    if (qrCode.size <= SMALL_QR_SIZE) {
+    let position = (size - 21) / 2 * 100 + 700 - 10;
+    if (size <= 25) {
         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(`
+    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}"
         />
-      `);
-    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 = `
+      `;
+}
+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="0"
-        width="${backgroundSize}"
-        height="${backgroundSize}"
+        x="${-padding}"
+        y="${-padding}"
+        width="${size}"
+        height="${size}"
         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
+}
+function renderDefinitions(options) {
+    return `<defs>
+      <g
         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"
-      />
+      >
+        <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}"
@@ -209,358 +413,511 @@ C500,479.991668 480.004166,500 395.996667,500 C312.001666,500 387.998334,500 304
       <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);
+    </defs>`;
+}
+const QrCodeEcc = {
+    LOW: {
+        ordinal: 0,
+        formatBits: 1
+    },
+    MEDIUM: {
+        ordinal: 1,
+        formatBits: 0
+    },
+    QUARTILE: {
+        ordinal: 2,
+        formatBits: 3
+    },
+    HIGH: {
+        ordinal: 3,
+        formatBits: 2
     }
-    static encodeBinary(data, ecl) {
-        const seg = QrSegment.makeBytes(data);
-        return QrCode.encodeSegments([
-            seg
-        ], ecl);
+};
+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
+        ]
     }
-    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);
+};
+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 (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);
+        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);
     }
-    getModule(x, y) {
-        return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
+    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());
     }
-    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>
-`;
+    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);
     }
-    drawFunctionPatterns() {
-        for(let i = 0; i < this.size; i++){
-            this.setFunctionModule(6, i, i % 2 === 0);
-            this.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);
         }
-        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();
+    };
+    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]);
     }
-    drawFormatBits(mask) {
-        const data = this.errorCorrectionLevel.formatBits << 3 | mask;
+    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++)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 <= 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 = this.version << 12 | rem;
+        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 = this.size - 11 + i % 3;
+            const a = size - 11 + i % 3;
             const b = Math.floor(i / 3);
-            this.setFunctionModule(a, b, color);
-            this.setFunctionModule(b, a, color);
+            setFunctionModule(a, b, color);
+            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);
+    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++;
+            }
         }
     }
-    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)));
+    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);
+        }
     }
-    setFunctionModule(x, y, isBlack) {
-        this.modules[y][x] = isBlack;
-        this.isFunction[y][x] = true;
+    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;
     }
-    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 {
+        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;
     }
-    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++;
-                }
-            }
+}
+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 (i !== 8 * data.length) throw 'Assertion error';
+        if (!isFunction[y][x] && invert) modules[y][x] = !modules[y][x];
     }
-    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];
+}
+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;
     }
-    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;
+    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;
         }
-        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;
+        addRunToHistory(runY, runHistory);
+        if (color) addRunToHistory(0, runHistory);
+        if (hasFinderLikePattern(runHistory)) result += PENALTY_N3;
     }
-    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;
-        }
+    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;
     }
-    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;
+    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));
     }
-    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];
+    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;
     }
-    static addRunToHistory(run, history) {
-        history.pop();
-        history.unshift(run);
+    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;
     }
-    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;
+    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);
     }
-    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());
+    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);
         }
-        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);
+    };
+}
+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;
         }
-        if (mask < 0 || mask > 7) throw 'Assertion error';
-        this.mask = mask;
-        this.applyMask(mask);
-        this.drawFormatBits(mask);
-        this.isFunction = [];
+    };
+}
+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;
 }
-_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", [
+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,
@@ -733,8 +1090,8 @@ _define_property__(QrCode, "ECC_CODEWORDS_PER_BLOCK", [
         30,
         30
     ]
-]);
-_define_property__(QrCode, "NUM_ERROR_CORRECTION_BLOCKS", [
+];
+const NUM_ERROR_CORRECTION_BLOCKS = [
     [
         -1,
         1,
@@ -907,193 +1264,10 @@ _define_property__(QrCode, "NUM_ERROR_CORRECTION_BLOCKS", [
         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 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';
@@ -1119,14 +1293,16 @@ function createQR(text, qrSizeOrOptions, classNameLegacy, legacyOptions) {
         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 : 96
+        incTileSize: 'number' == typeof options.incTileSize ? options.incTileSize : INC_TILE_SIZE
     };
-    const segments = QrSegment.makeSegments(text);
-    const qrCode = QrCode.encodeSegments(segments, eccLevels[fallbackOptions.ecc], 1, 40, -1, true);
+    const segments = makeSegments(text);
+    const qrCode = encodeSegments(segments, eccLevels[fallbackOptions.ecc], 1, 40, -1, true);
     const svgCode = convertSegmentsToSvgString(qrCode, fallbackOptions);
     return svgCode;
 }