@liquid-js/qr-code-styling 5.0.0-2 → 5.0.0-4

package/lib/qr-code-styling-node.js

@@ -29,34 +29,42 @@ function mergeDeep(target, ...sources) {
 
 var GradientType, DotType, CornerDotType, CornerSquareType, ShapeType, ImageMode;
 
-function sanitizeGradient(gradient_newGradient) {
-    if (!(gradient_newGradient = {
-        ...gradient_newGradient
-    }).colorStops || !gradient_newGradient.colorStops.length) throw Error("Field 'colorStops' is required in gradient");
-    return gradient_newGradient.rotation = gradient_newGradient.rotation ? Number(gradient_newGradient.rotation) : 0, 
-    gradient_newGradient.colorStops = gradient_newGradient.colorStops.map(colorStop => ({
+function sanitizeGradient(gradient) {
+    let newGradient = {
+        ...gradient
+    };
+    if (!newGradient.colorStops || !newGradient.colorStops.length) throw new Error("Field 'colorStops' is required in gradient");
+    return newGradient.rotation ? newGradient.rotation = Number(newGradient.rotation) : newGradient.rotation = 0, 
+    newGradient.colorStops = newGradient.colorStops.map(colorStop => ({
         ...colorStop,
         offset: Number(colorStop.offset)
-    })), gradient_newGradient;
+    })), newGradient;
 }
 
-(GradientType = GradientType ||= {}).radial = "radial", GradientType.linear = "linear", 
-(DotType = DotType ||= {}).dot = "dot", DotType.randomDot = "random-dot", DotType.rounded = "rounded", 
-DotType.extraRounded = "extra-rounded", DotType.verticalLine = "vertical-line", 
-DotType.horizontalLine = "horizontal-line", DotType.classy = "classy", DotType.classyRounded = "classy-rounded", 
-DotType.square = "square", DotType.smallSquare = "small-square", DotType.tinySquare = "tiny-square", 
-DotType.diamond = "diamond", DotType.wave = "wave", DotType.heart = "heart", DotType.star = "star", 
-DotType.weave = "weave", DotType.pentagon = "pentagon", DotType.hexagon = "hexagon", 
-DotType.zebraHorizontal = "zebra-horizontal", DotType.zebraVertical = "zebra-vertical", 
-(CornerDotType = CornerDotType ||= {}).dot = "dot", CornerDotType.square = "square", 
-CornerDotType.heart = "heart", CornerDotType.extraRounded = "extra-rounded", CornerDotType.classy = "classy", 
-CornerDotType.inpoint = "inpoint", CornerDotType.outpoint = "outpoint", CornerDotType.star = "star", 
-CornerDotType.pentagon = "pentagon", CornerDotType.hexagon = "hexagon", CornerDotType.diamond = "diamond", 
-(CornerSquareType = CornerSquareType ||= {}).dot = "dot", CornerSquareType.square = "square", 
-CornerSquareType.extraRounded = "extra-rounded", CornerSquareType.classy = "classy", 
-CornerSquareType.inpoint = "inpoint", CornerSquareType.outpoint = "outpoint", CornerSquareType.centerCircle = "center-circle", 
-(ShapeType = ShapeType ||= {}).square = "square", ShapeType.circle = "circle", (ImageMode = ImageMode ||= {}).center = "center", 
-ImageMode.overlay = "overlay", ImageMode.background = "background";
+!function(GradientType) {
+    GradientType.radial = "radial", GradientType.linear = "linear";
+}(GradientType || (GradientType = {})), function(DotType) {
+    DotType.dot = "dot", DotType.randomDot = "random-dot", DotType.rounded = "rounded", 
+    DotType.extraRounded = "extra-rounded", DotType.verticalLine = "vertical-line", 
+    DotType.horizontalLine = "horizontal-line", DotType.classy = "classy", DotType.classyRounded = "classy-rounded", 
+    DotType.square = "square", DotType.smallSquare = "small-square", DotType.tinySquare = "tiny-square", 
+    DotType.diamond = "diamond", DotType.wave = "wave", DotType.heart = "heart", DotType.star = "star", 
+    DotType.weave = "weave", DotType.pentagon = "pentagon", DotType.hexagon = "hexagon", 
+    DotType.zebraHorizontal = "zebra-horizontal", DotType.zebraVertical = "zebra-vertical";
+}(DotType || (DotType = {})), function(CornerDotType) {
+    CornerDotType.dot = "dot", CornerDotType.square = "square", CornerDotType.heart = "heart", 
+    CornerDotType.extraRounded = "extra-rounded", CornerDotType.classy = "classy", CornerDotType.inpoint = "inpoint", 
+    CornerDotType.outpoint = "outpoint", CornerDotType.star = "star", CornerDotType.pentagon = "pentagon", 
+    CornerDotType.hexagon = "hexagon", CornerDotType.diamond = "diamond";
+}(CornerDotType || (CornerDotType = {})), function(CornerSquareType) {
+    CornerSquareType.dot = "dot", CornerSquareType.square = "square", CornerSquareType.extraRounded = "extra-rounded", 
+    CornerSquareType.classy = "classy", CornerSquareType.inpoint = "inpoint", CornerSquareType.outpoint = "outpoint", 
+    CornerSquareType.centerCircle = "center-circle";
+}(CornerSquareType || (CornerSquareType = {})), function(ShapeType) {
+    ShapeType.square = "square", ShapeType.circle = "circle";
+}(ShapeType || (ShapeType = {})), function(ImageMode) {
+    ImageMode.center = "center", ImageMode.overlay = "overlay", ImageMode.background = "background";
+}(ImageMode || (ImageMode = {}));
 
 let defaultOptions = {
     document: void 0,
@@ -85,32 +93,33 @@ let defaultOptions = {
     }
 };
 
-function sanitizeOptions(newOptions_options) {
-    return (newOptions_options = {
-        ...newOptions_options
-    }).imageOptions = {
-        ...newOptions_options.imageOptions,
-        imageSize: Math.min(1, Number(newOptions_options.imageOptions.imageSize)) || 1,
-        margin: Number(newOptions_options.imageOptions.margin),
+function sanitizeOptions(options) {
+    let newOptions = {
+        ...options
+    };
+    return newOptions.imageOptions = {
+        ...newOptions.imageOptions,
+        imageSize: Math.min(1, Number(newOptions.imageOptions.imageSize)) || 1,
+        margin: Number(newOptions.imageOptions.margin),
         fill: {
-            ...newOptions_options.imageOptions.fill
+            ...newOptions.imageOptions.fill
         }
-    }, newOptions_options.imageOptions.mode == ImageMode.overlay && (newOptions_options.imageOptions.margin = 0), 
-    newOptions_options.imageOptions.fill.gradient && (newOptions_options.imageOptions.fill.gradient = sanitizeGradient(newOptions_options.imageOptions.fill.gradient)), 
-    newOptions_options.dotsOptions = {
-        ...newOptions_options.dotsOptions
-    }, newOptions_options.dotsOptions.gradient && (newOptions_options.dotsOptions.gradient = sanitizeGradient(newOptions_options.dotsOptions.gradient)), 
-    newOptions_options.dotsOptions.size = Math.round(Math.max(0, newOptions_options.dotsOptions.size) || 10), 
-    newOptions_options.cornersSquareOptions && (newOptions_options.cornersSquareOptions = {
-        ...newOptions_options.cornersSquareOptions
-    }, newOptions_options.cornersSquareOptions.gradient && (newOptions_options.cornersSquareOptions.gradient = sanitizeGradient(newOptions_options.cornersSquareOptions.gradient))), 
-    newOptions_options.cornersDotOptions && (newOptions_options.cornersDotOptions = {
-        ...newOptions_options.cornersDotOptions
-    }, newOptions_options.cornersDotOptions.gradient && (newOptions_options.cornersDotOptions.gradient = sanitizeGradient(newOptions_options.cornersDotOptions.gradient))), 
-    newOptions_options.backgroundOptions && (newOptions_options.backgroundOptions = {
-        ...newOptions_options.backgroundOptions
-    }, newOptions_options.backgroundOptions.gradient && (newOptions_options.backgroundOptions.gradient = sanitizeGradient(newOptions_options.backgroundOptions.gradient))), 
-    newOptions_options.document || (newOptions_options.document = document), newOptions_options;
+    }, newOptions.imageOptions.mode == ImageMode.overlay && (newOptions.imageOptions.margin = 0), 
+    newOptions.imageOptions.fill.gradient && (newOptions.imageOptions.fill.gradient = sanitizeGradient(newOptions.imageOptions.fill.gradient)), 
+    newOptions.dotsOptions = {
+        ...newOptions.dotsOptions
+    }, newOptions.dotsOptions.gradient && (newOptions.dotsOptions.gradient = sanitizeGradient(newOptions.dotsOptions.gradient)), 
+    newOptions.dotsOptions.size = Math.round(Math.max(0, newOptions.dotsOptions.size) || 10), 
+    newOptions.cornersSquareOptions && (newOptions.cornersSquareOptions = {
+        ...newOptions.cornersSquareOptions
+    }, newOptions.cornersSquareOptions.gradient && (newOptions.cornersSquareOptions.gradient = sanitizeGradient(newOptions.cornersSquareOptions.gradient))), 
+    newOptions.cornersDotOptions && (newOptions.cornersDotOptions = {
+        ...newOptions.cornersDotOptions
+    }, newOptions.cornersDotOptions.gradient && (newOptions.cornersDotOptions.gradient = sanitizeGradient(newOptions.cornersDotOptions.gradient))), 
+    newOptions.backgroundOptions && (newOptions.backgroundOptions = {
+        ...newOptions.backgroundOptions
+    }, newOptions.backgroundOptions.gradient && (newOptions.backgroundOptions.gradient = sanitizeGradient(newOptions.backgroundOptions.gradient))), 
+    newOptions.document || (newOptions.document = document), newOptions;
 }
 
 let ErrorCorrectionPercents = {
@@ -123,7 +132,7 @@ let ErrorCorrectionPercents = {
 let rx = /\.?0+$/;
 
 function numToAttr(value) {
-    return value.toFixed(7).replace(rx, "");
+    return "string" == typeof value ? value : value.toFixed(7).replace(rx, "");
 }
 
 function svgPath(strings, ...values) {
@@ -133,58 +142,52 @@ function svgPath(strings, ...values) {
     }, "").trim().replace(/[\s\n\r]+/gim, " ");
 }
 
-function rotateFigure({draw: draw_element, ...args}) {
-    let {x, y, size, rotation = 0} = args, cx = x + size / 2, cy = y + size / 2;
-    return draw_element = draw_element(args), rotation && (Array.isArray(draw_element) ? draw_element : [ draw_element ]).forEach(el => el.setAttribute("transform", `rotate(${numToAttr(180 * rotation / Math.PI)},${cx},${cy})`)), 
-    draw_element;
+function rotateFigure({draw, ...args}) {
+    let {x, y, size, rotation = 0} = args, cx = x + size / 2, cy = y + size / 2, element = draw(args);
+    return rotation && (Array.isArray(element) ? element : [ element ]).forEach(el => el.setAttribute("transform", `rotate(${numToAttr(180 * rotation / Math.PI)},${cx},${cy})`)), 
+    element;
 }
 
 let DotElements = {
     dot: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "circle")).setAttribute("cx", numToAttr(x + size / 2)), 
-        args.setAttribute("cy", numToAttr(y + size / 2)), args.setAttribute("r", numToAttr(size / 2)), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+        return element.setAttribute("cx", numToAttr(x + size / 2)), element.setAttribute("cy", numToAttr(y + size / 2)), 
+        element.setAttribute("r", numToAttr(size / 2)), element;
     },
     square: (args, {width = args.size, height = args.size} = {}) => {
-        const {x, y, size, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "rect")).setAttribute("x", numToAttr(x + (size - width) / 2)), 
-        args.setAttribute("y", numToAttr(y + (size - height) / 2)), args.setAttribute("width", numToAttr(width)), 
-        args.setAttribute("height", numToAttr(height)), args;
+        const {x, y, size, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        return element.setAttribute("x", numToAttr(x + (size - width) / 2)), element.setAttribute("y", numToAttr(y + (size - height) / 2)), 
+        element.setAttribute("width", numToAttr(width)), element.setAttribute("height", numToAttr(height)), 
+        element;
     },
     sideRounded: (args, {height = args.size} = {}) => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", svgPath`M ${x} ${y + (size - height) / 2} v ${height} h ${size / 2} a ${height / 2} ${height / 2} 0 0 0 0 ${-height} z`), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y + (size - height) / 2} v ${height} h ${size / 2} a ${height / 2} ${height / 2} 0 0 0 0 ${-height} z`), 
+        element;
     },
     cornerRounded: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} v ${-size / 2} a ${size / 2} ${size / 2} 0 0 0 ${-size / 2} ${-size / 2} z`), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} v ${-size / 2} a ${size / 2} ${size / 2} 0 0 0 ${-size / 2} ${-size / 2} z`), 
+        element;
     },
     cornerExtraRounded: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} a ${size} ${size} 0 0 0 ${-size} ${-size} z`), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} a ${size} ${size} 0 0 0 ${-size} ${-size} z`), 
+        element;
     },
     cornersRounded: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", svgPath`M ${x} ${y} v ${size / 2} a ${size / 2} ${size / 2} 0 0 0 ${size / 2} ${size / 2} h ${size / 2} v ${-size / 2} a ${size / 2} ${size / 2} 0 0 0 ${-size / 2} ${-size / 2} z`), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y} v ${size / 2} a ${size / 2} ${size / 2} 0 0 0 ${size / 2} ${size / 2} h ${size / 2} v ${-size / 2} a ${size / 2} ${size / 2} 0 0 0 ${-size / 2} ${-size / 2} z`), 
+        element;
     },
     wave: args => {
-        const {size, x, y, document} = args;
-        var a1_c23y = 5 * Math.PI / 180, a2_c31y = 65 * Math.PI / 180;
-        args = size * (1 - .65 * Math.sin(a1_c23y)), a1_c23y = -size * (.95 - .65 * Math.cos(a1_c23y));
-        const c31x = -size * Math.sin(a2_c31y) / 2;
-        a2_c31y = size * Math.cos(a2_c31y) / 2;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return element.setAttribute("d", svgPath`M ${x} ${y + size} c ${.65 * size} 0 ${args} ${a1_c23y} ${size} ${.95 * -size} c ${c31x} ${a2_c31y} ${-size / 2} ${size * (.95 - 1)} ${-size} ${size * (.95 - 1)} z`), 
+        const {size, x, y, document} = args, a1 = 5 * Math.PI / 180, a2 = 65 * Math.PI / 180, c23x = size * (1 - .65 * Math.sin(a1)), c23y = -size * (.95 - .65 * Math.cos(a1)), c31x = -size * Math.sin(a2) / 2, c31y = size * Math.cos(a2) / 2, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y + size} c ${.65 * size} 0 ${c23x} ${c23y} ${size} ${.95 * -size} c ${c31x} ${c31y} ${-size / 2} ${size * (.95 - 1)} ${-size} ${size * (.95 - 1)} z`), 
         element;
     },
     heart: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", function(path, {x, y, size}) {
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", function(path, {x, y, size}) {
             let move = !1, i = 0;
             return path.map(v => "string" == typeof v ? (i = 0, move = v.toUpperCase() == v, 
             v) : (i++, v *= size, move && (v += i % 2 == 1 ? x : y), numToAttr(v))).join(" ");
@@ -192,35 +195,35 @@ let DotElements = {
             x,
             y,
             size
-        })), args;
+        })), element;
     },
     rounded: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "rect")).setAttribute("x", numToAttr(x)), 
-        args.setAttribute("y", numToAttr(y)), args.setAttribute("width", numToAttr(size)), 
-        args.setAttribute("height", numToAttr(size)), args.setAttribute("rx", numToAttr(size / 4)), 
-        args.setAttribute("ry", numToAttr(size / 4)), args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        return element.setAttribute("x", numToAttr(x)), element.setAttribute("y", numToAttr(y)), 
+        element.setAttribute("width", numToAttr(size)), element.setAttribute("height", numToAttr(size)), 
+        element.setAttribute("rx", numToAttr(size / 4)), element.setAttribute("ry", numToAttr(size / 4)), 
+        element;
     },
     classy: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * args} v ${2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * args} ${2.5 * args} h ${4.5 * args} v ${-4.5 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * -args} h ${-2 * args} H ${x} z`), 
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * dotSize} v ${2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * dotSize} ${2.5 * dotSize} h ${4.5 * dotSize} v ${-4.5 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * -dotSize} h ${-2 * dotSize} H ${x} z`), 
         element;
     },
     inpoint: args => {
-        const {size, x, y, document} = args;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", svgPath`M ${x} ${y + size / 2} v ${size / 4} a ${size / 4} ${size / 4} 0 0 0 ${size / 4} ${size / 4} h ${size / 4 * 3} v ${-size / 4 * 3} a ${size / 4} ${size / 4} 0 0 0 ${-size / 4} ${-size / 4} h ${-size / 2} a ${size / 4} ${size / 4} 0 0 0 ${-size / 4} ${size / 4} z`), 
-        args;
+        const {size, x, y, document} = args, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x} ${y + size / 2} v ${size / 4} a ${size / 4} ${size / 4} 0 0 0 ${size / 4} ${size / 4} h ${size / 4 * 3} v ${-size / 4 * 3} a ${size / 4} ${size / 4} 0 0 0 ${-size / 4} ${-size / 4} h ${-size / 2} a ${size / 4} ${size / 4} 0 0 0 ${-size / 4} ${size / 4} z`), 
+        element;
     },
     star: (args, {spikes = 5, outerRadius = args.size / 2, innerRadius = args.size / 4} = {}) => {
-        const {size, x, y, document} = args, cx = x + size / 2, cy = y + size / 2, angle = Math.PI / spikes;
-        return (args = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("d", Array(2 * spikes).fill(0).map((__radius, i) => svgPath`${0 === i ? "M" : "L"} ${cx + (__radius = i % 2 == 0 ? outerRadius : innerRadius) * Math.sin(i * angle)} ${cy - __radius * Math.cos(i * angle)}`).join(" ")), 
-        args;
+        const {size, x, y, document} = args, cx = x + size / 2, cy = y + size / 2, angle = Math.PI / spikes, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", Array(2 * spikes).fill(0).map((_, i) => {
+            const radius = i % 2 == 0 ? outerRadius : innerRadius;
+            return svgPath`${0 === i ? "M" : "L"} ${cx + radius * Math.sin(i * angle)} ${cy - radius * Math.cos(i * angle)}`;
+        }).join(" ")), element;
     },
     weave: args => {
-        const {size, x, y, document} = args, notch = (size - (args = .6 * size)) / 2, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return element.setAttribute("d", svgPath`M ${x + notch} ${y} l ${args} 0 l 0 ${notch} l ${notch} 0 l 0 ${args} l ${-notch} 0 l 0 ${notch} l ${-args} 0 l 0 ${-notch} l ${-notch} 0 l 0 ${-args} l ${notch} 0 z`), 
+        const {size, x, y, document} = args, thickness = .6 * size, notch = (size - thickness) / 2, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        return element.setAttribute("d", svgPath`M ${x + notch} ${y} l ${thickness} 0 l 0 ${notch} l ${notch} 0 l 0 ${thickness} l ${-notch} 0 l 0 ${notch} l ${-thickness} 0 l 0 ${-notch} l ${-notch} 0 l 0 ${-thickness} l ${notch} 0 z`), 
         element;
     }
 }, qrCornerDotFigures = {
@@ -269,70 +272,49 @@ let DotElements = {
             height: .85 * args2.size
         })
     })
-}, SquareElements = {
+};
+
+let SquareElements = {
     dot: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x + size / 2} ${y} a ${size / 2} ${size / 2} 0 1 0 0.1 0 z m 0 ${args} a ${size / 2 - args} ${size / 2 - args} 0 1 1 -0.1 0 Z`);
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x + size / 2} ${y} a ${size / 2} ${size / 2} 0 1 0 0.1 0 z m 0 ${dotSize} a ${size / 2 - dotSize} ${size / 2 - dotSize} 0 1 1 -0.1 0 Z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + size / 2} ${y - args} a ${size / 2 + args} ${size / 2 + args} 0 1 0 0.1 0 z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + size / 2} ${y - dotSize} a ${size / 2 + dotSize} ${size / 2 + dotSize} 0 1 0 0.1 0 z`), 
         [ element, fill ];
     },
     square: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} v ${-size} z M ${x + args} ${y + args} h ${size - 2 * args} v ${size - 2 * args} h ${2 * args - size} z`);
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y} v ${size} h ${size} v ${-size} z M ${x + dotSize} ${y + dotSize} h ${size - 2 * dotSize} v ${size - 2 * dotSize} h ${2 * dotSize - size} z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - args} ${y - args} h ${size + 2 * args} v ${size + 2 * args} h ${-size - 2 * args} z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - dotSize} ${y - dotSize} h ${size + 2 * dotSize} v ${size + 2 * dotSize} h ${-size - 2 * dotSize} z`), 
         [ element, fill ];
     },
     extraRounded: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * args} v ${2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * args} ${2.5 * args} h ${2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * args} ${2.5 * -args} v ${-2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * -args} h ${-2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * args} z M ${x + 2.5 * args} ${y + args} h ${2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * args} ${1.5 * args} v ${2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * -args} ${1.5 * args} h ${-2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * -args} ${1.5 * -args} v ${-2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * args} ${1.5 * -args} z`);
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * dotSize} v ${2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * dotSize} ${2.5 * dotSize} h ${2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * dotSize} ${2.5 * -dotSize} v ${-2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * -dotSize} h ${-2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * dotSize} z M ${x + 2.5 * dotSize} ${y + dotSize} h ${2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * dotSize} ${1.5 * dotSize} v ${2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * -dotSize} ${1.5 * dotSize} h ${-2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * -dotSize} ${1.5 * -dotSize} v ${-2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * dotSize} ${1.5 * -dotSize} z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - args} ${y + 2.5 * args} v ${2 * args} a ${3.5 * args} ${3.5 * args} 0 0 0 ${3.5 * args} ${3.5 * args} h ${2 * args} a ${3.5 * args} ${3.5 * args} 0 0 0 ${3.5 * args} ${3.5 * -args} v ${-2 * args} a ${3.5 * args} ${3.5 * args} 0 0 0 ${3.5 * -args} ${3.5 * -args} h ${-2 * args} a ${3.5 * args} ${3.5 * args} 0 0 0 ${3.5 * -args} ${3.5 * args} z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - dotSize} ${y + 2.5 * dotSize} v ${2 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 0 ${3.5 * dotSize} ${3.5 * dotSize} h ${2 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 0 ${3.5 * dotSize} ${3.5 * -dotSize} v ${-2 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 0 ${3.5 * -dotSize} ${3.5 * -dotSize} h ${-2 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 0 ${3.5 * -dotSize} ${3.5 * dotSize} z`), 
         [ element, fill ];
     },
     classy: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * args} v ${2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * args} ${2.5 * args} h ${4.5 * args} v ${-4.5 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * -args} h ${-2 * args} H ${x} z M ${x + 2.5 * args} ${y + args} h ${2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * args} ${1.5 * args} v ${3.5 * args} h ${-3.5 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * -args} ${1.5 * -args} v ${-3.5 * args} z`);
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * dotSize} v ${2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * dotSize} ${2.5 * dotSize} h ${4.5 * dotSize} v ${-4.5 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * -dotSize} h ${-2 * dotSize} H ${x} z M ${x + 2.5 * dotSize} ${y + dotSize} h ${2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * dotSize} ${1.5 * dotSize} v ${3.5 * dotSize} h ${-3.5 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * -dotSize} ${1.5 * -dotSize} v ${-3.5 * dotSize} z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + .5 * args} ${y - args} h ${4 * args} a ${3.5 * args} ${3.5 * args} 0 0 1 ${3.5 * args} ${3.5 * args} v ${5.5 * args} h ${-5.5 * args} a ${3.5 * args} ${3.5 * args} 0 0 1 ${3.5 * -args} ${3.5 * -args} v ${-5.5 * args} z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + .5 * dotSize} ${y - dotSize} h ${4 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 1 ${3.5 * dotSize} ${3.5 * dotSize} v ${5.5 * dotSize} h ${-5.5 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 1 ${3.5 * -dotSize} ${3.5 * -dotSize} v ${-5.5 * dotSize} z`), 
         [ element, fill ];
     },
     inpoint: args => {
-        const {size, x, y, document} = args;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * args} v ${2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * args} ${2.5 * args} h ${4.5 * args} v ${-4.5 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * -args} h ${-2 * args} a ${2.5 * args} ${2.5 * args} 0 0 0 ${2.5 * -args} ${2.5 * args} z M ${x + 2.5 * args} ${y + args} h ${2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * args} ${1.5 * args} v ${3.5 * args} h ${-3.5 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * -args} ${1.5 * -args} v ${-2 * args} a ${1.5 * args} ${1.5 * args} 0 0 1 ${1.5 * args} ${1.5 * -args} z`);
+        const {size, x, y, document} = args, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y + 2.5 * dotSize} v ${2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * dotSize} ${2.5 * dotSize} h ${4.5 * dotSize} v ${-4.5 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * -dotSize} h ${-2 * dotSize} a ${2.5 * dotSize} ${2.5 * dotSize} 0 0 0 ${2.5 * -dotSize} ${2.5 * dotSize} z M ${x + 2.5 * dotSize} ${y + dotSize} h ${2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * dotSize} ${1.5 * dotSize} v ${3.5 * dotSize} h ${-3.5 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * -dotSize} ${1.5 * -dotSize} v ${-2 * dotSize} a ${1.5 * dotSize} ${1.5 * dotSize} 0 0 1 ${1.5 * dotSize} ${1.5 * -dotSize} z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + .5 * args} ${y - args} h ${4 * args} a ${3.5 * args} ${3.5 * args} 0 0 1 ${3.5 * args} ${3.5 * args} v ${5.5 * args} h ${-5.5 * args} a ${3.5 * args} ${3.5 * args} 0 0 1 ${3.5 * -args} ${3.5 * -args} v ${-2 * args} a ${3.5 * args} ${3.5 * args} 0 0 1 ${3.5 * args} ${3.5 * -args} z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x + .5 * dotSize} ${y - dotSize} h ${4 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 1 ${3.5 * dotSize} ${3.5 * dotSize} v ${5.5 * dotSize} h ${-5.5 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 1 ${3.5 * -dotSize} ${3.5 * -dotSize} v ${-2 * dotSize} a ${3.5 * dotSize} ${3.5 * dotSize} 0 0 1 ${3.5 * dotSize} ${3.5 * -dotSize} z`), 
         [ element, fill ];
     },
     centerCircle: args => {
-        const {x, y, size} = args;
-        var circleRadius_fill = size / 2.5;
-        const cx = x + size / 2, cy = y + size / 2;
-        args = size / 7;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y} h ${size} v ${size} h ${-size} z M ${cx - circleRadius_fill} ${cy} a ${circleRadius_fill} ${circleRadius_fill} 0 1 0 ${2 * circleRadius_fill} 0 a ${circleRadius_fill} ${circleRadius_fill} 0 1 0 ${2 * -circleRadius_fill} 0 z`), 
-        (circleRadius_fill = document.createElementNS("http://www.w3.org/2000/svg", "path")).setAttribute("clip-rule", "evenodd"), 
-        circleRadius_fill.setAttribute("d", svgPath`M ${x - args} ${y - args} h ${size + 2 * args} v ${size + 2 * args} h ${-size - 2 * args} z`), 
-        [ element, circleRadius_fill ];
-    },
-    cornerCut: args => {
-        const {x, y, size} = args;
-        args = size / 8;
-        const element = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", `M ${x} ${y} L ${x + size} ${y} L ${x + size} ${y + size - args} Q ${x + size} ${y + size} ${x + size - args} ${y + size} L ${x + args} ${y + size} Q ${x} ${y + size - args} ${x} ${y + size - args} Z M ${x + args} ${y + args} L ${x + size - args} ${y + args} L ${x + size - args} ${y + size - args} L ${x + args} ${y + size - args} Z`);
+        const {x, y, size} = args, circleRadius = size / 2.5, cx = x + size / 2, cy = y + size / 2, dotSize = size / 7, element = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        element.setAttribute("clip-rule", "evenodd"), element.setAttribute("d", svgPath`M ${x} ${y} h ${size} v ${size} h ${-size} z M ${cx - circleRadius} ${cy} a ${circleRadius} ${circleRadius} 0 1 0 ${2 * circleRadius} 0 a ${circleRadius} ${circleRadius} 0 1 0 ${2 * -circleRadius} 0 z`);
         const fill = document.createElementNS("http://www.w3.org/2000/svg", "path");
-        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - args} ${y - args} h ${size + 2 * args} v ${size + 2 * args} h ${-size - 2 * args} z`), 
+        return fill.setAttribute("clip-rule", "evenodd"), fill.setAttribute("d", svgPath`M ${x - dotSize} ${y - dotSize} h ${size + 2 * dotSize} v ${size + 2 * dotSize} h ${-size - 2 * dotSize} z`), 
         [ element, fill ];
     }
 }, qrCornerSquareFigures = {
@@ -353,38 +335,49 @@ let DotElements = {
         draw: SquareElements.inpoint
     }),
     [CornerSquareType.centerCircle]: args => SquareElements.centerCircle(args)
-}, compoundDots_rounded = ({x, y, size, document, getNeighbor: bottomNeighbor_getNeighbor}, {corner: corner_rotation = DotElements.cornerRounded, end = DotElements.sideRounded} = {}) => {
-    const leftNeighbor = bottomNeighbor_getNeighbor ? +bottomNeighbor_getNeighbor(-1, 0) : 0, rightNeighbor = bottomNeighbor_getNeighbor ? +bottomNeighbor_getNeighbor(1, 0) : 0, topNeighbor = bottomNeighbor_getNeighbor ? +bottomNeighbor_getNeighbor(0, -1) : 0, neighborsCount = leftNeighbor + rightNeighbor + topNeighbor + (bottomNeighbor_getNeighbor = bottomNeighbor_getNeighbor ? +bottomNeighbor_getNeighbor(0, 1) : 0);
-    return 0 === neighborsCount ? DotElements.dot({
+};
+
+let compoundDots_rounded = ({x, y, size, document, getNeighbor}, {corner = DotElements.cornerRounded, end = DotElements.sideRounded} = {}) => {
+    const leftNeighbor = getNeighbor ? +getNeighbor(-1, 0) : 0, rightNeighbor = getNeighbor ? +getNeighbor(1, 0) : 0, topNeighbor = getNeighbor ? +getNeighbor(0, -1) : 0, bottomNeighbor = getNeighbor ? +getNeighbor(0, 1) : 0, neighborsCount = leftNeighbor + rightNeighbor + topNeighbor + bottomNeighbor;
+    if (0 === neighborsCount) return DotElements.dot({
         x,
         y,
         size,
         document
-    }) : neighborsCount > 2 || leftNeighbor && rightNeighbor || topNeighbor && bottomNeighbor_getNeighbor ? DotElements.square({
+    });
+    if (neighborsCount > 2 || leftNeighbor && rightNeighbor || topNeighbor && bottomNeighbor) return DotElements.square({
         x,
         y,
         size,
         document
-    }) : 2 === neighborsCount ? (end = 0, leftNeighbor && topNeighbor ? end = Math.PI / 2 : topNeighbor && rightNeighbor ? end = Math.PI : rightNeighbor && bottomNeighbor_getNeighbor && (end = -Math.PI / 2), 
-    rotateFigure({
-        x,
-        y,
-        size,
-        rotation: end,
-        document,
-        draw: corner_rotation
-    })) : (corner_rotation = 0, topNeighbor ? corner_rotation = Math.PI / 2 : rightNeighbor ? corner_rotation = Math.PI : bottomNeighbor_getNeighbor && (corner_rotation = -Math.PI / 2), 
-    rotateFigure({
-        x,
-        y,
-        size,
-        rotation: corner_rotation,
-        document,
-        draw: end
-    }));
-}, compoundDots_classy = ({x, y, size, document, getNeighbor: bottomNeighbor}, {corner = DotElements.cornerRounded} = {}) => {
-    const leftNeighbor = bottomNeighbor ? +bottomNeighbor(-1, 0) : 0, rightNeighbor = bottomNeighbor ? +bottomNeighbor(1, 0) : 0, topNeighbor = bottomNeighbor ? +bottomNeighbor(0, -1) : 0;
-    return leftNeighbor + rightNeighbor + topNeighbor + (bottomNeighbor = bottomNeighbor ? +bottomNeighbor(0, 1) : 0) === 0 ? rotateFigure({
+    });
+    if (2 === neighborsCount) {
+        let rotation = 0;
+        return leftNeighbor && topNeighbor ? rotation = Math.PI / 2 : topNeighbor && rightNeighbor ? rotation = Math.PI : rightNeighbor && bottomNeighbor && (rotation = -Math.PI / 2), 
+        rotateFigure({
+            x,
+            y,
+            size,
+            rotation,
+            document,
+            draw: corner
+        });
+    }
+    {
+        let rotation = 0;
+        return topNeighbor ? rotation = Math.PI / 2 : rightNeighbor ? rotation = Math.PI : bottomNeighbor && (rotation = -Math.PI / 2), 
+        rotateFigure({
+            x,
+            y,
+            size,
+            rotation,
+            document,
+            draw: end
+        });
+    }
+}, compoundDots_classy = ({x, y, size, document, getNeighbor}, {corner = DotElements.cornerRounded} = {}) => {
+    const leftNeighbor = getNeighbor ? +getNeighbor(-1, 0) : 0, rightNeighbor = getNeighbor ? +getNeighbor(1, 0) : 0, topNeighbor = getNeighbor ? +getNeighbor(0, -1) : 0, bottomNeighbor = getNeighbor ? +getNeighbor(0, 1) : 0;
+    return 0 === leftNeighbor + rightNeighbor + topNeighbor + bottomNeighbor ? rotateFigure({
         x,
         y,
         size,
@@ -411,15 +404,15 @@ let DotElements = {
         document,
         draw: corner
     });
-}, compoundDots_line = ({x, y, size, document, getNeighbor: bottomNeighbor}, {stripe = size, rotation = 0} = {}) => {
-    const topNeighbor = bottomNeighbor ? +bottomNeighbor(0, -1) : 0;
-    return bottomNeighbor = bottomNeighbor ? +bottomNeighbor(0, 1) : 0, topNeighbor && bottomNeighbor ? rotateFigure({
+}, compoundDots_line = ({x, y, size, document, getNeighbor}, {stripe = size, rotation = 0} = {}) => {
+    const topNeighbor = getNeighbor ? +getNeighbor(0, -1) : 0, bottomNeighbor = getNeighbor ? +getNeighbor(0, 1) : 0;
+    return topNeighbor && bottomNeighbor ? rotateFigure({
         x,
         y,
         size,
         rotation,
         document,
-        draw: () => DotElements.square({
+        draw: _ => DotElements.square({
             x,
             y,
             size,
@@ -451,7 +444,7 @@ let DotElements = {
         size,
         rotation,
         document,
-        draw: () => DotElements.dot({
+        draw: _ => DotElements.dot({
             x: x + (size - stripe) / 2,
             y: y + (size - stripe) / 2,
             size: stripe,
@@ -460,10 +453,13 @@ let DotElements = {
     });
 }, qrDotFigures = {
     [DotType.dot]: args => DotElements.dot(args),
-    [DotType.randomDot]: ({size, ...args}) => DotElements.dot({
-        ...args,
-        size: size * (.25 * Math.random() + .75)
-    }),
+    [DotType.randomDot]: ({size, ...args}) => {
+        const randomFactor = .25 * Math.random() + .75;
+        return DotElements.dot({
+            ...args,
+            size: size * randomFactor
+        });
+    },
     [DotType.rounded]: args => compoundDots_rounded(args),
     [DotType.extraRounded]: args => compoundDots_rounded(args, {
         corner: DotElements.cornerExtraRounded
@@ -529,8 +525,18 @@ let DotElements = {
     })
 };
 
-function getQrDotFigure(type) {
-    return qrDotFigures[type] || qrDotFigures[DotType.square];
+function getQrDotFigure(type, plugins) {
+    let defaultDraw = qrDotFigures[type] || qrDotFigures[DotType.square];
+    if (!plugins?.length) return defaultDraw;
+    let drawPlugin = function(plugins) {
+        return args => {
+            for (let plugin of plugins) {
+                let el = plugin.drawDot?.(args);
+                if (el) return el;
+            }
+        };
+    }(plugins);
+    return args => drawPlugin(args) || defaultDraw(args);
 }
 
 let browserImageTools = {
@@ -562,25 +568,32 @@ let browserImageTools = {
     })
 };
 
-function parseColor(base) {
-    var m_parts = [];
-    let alpha = 1;
-    if ("#" === (base = base.toLowerCase())[0]) {
-        let size = (base = base.slice(1)).length;
-        size <= 4 ? (m_parts = [ parseInt(base[0] + base[0], 16), parseInt(base[1] + base[1], 16), parseInt(base[2] + base[2], 16) ], 
-        4 === size && (alpha = parseInt(base[3] + base[3], 16) / 255)) : (m_parts = [ parseInt(base[0] + base[1], 16), parseInt(base[2] + base[3], 16), parseInt(base[4] + base[5], 16) ], 
-        8 === size && (alpha = parseInt(base[6] + base[7], 16) / 255)), m_parts[0] || (m_parts[0] = 0), 
-        m_parts[1] || (m_parts[1] = 0), m_parts[2] || (m_parts[2] = 0);
+function parseColor(cstr) {
+    let m, parts = [], alpha = 1;
+    if ("#" === (cstr = cstr.toLowerCase())[0]) {
+        let base = cstr.slice(1), size = base.length;
+        size <= 4 ? (parts = [ parseInt(base[0] + base[0], 16), parseInt(base[1] + base[1], 16), parseInt(base[2] + base[2], 16) ], 
+        4 === size && (alpha = parseInt(base[3] + base[3], 16) / 255)) : (parts = [ parseInt(base[0] + base[1], 16), parseInt(base[2] + base[3], 16), parseInt(base[4] + base[5], 16) ], 
+        8 === size && (alpha = parseInt(base[6] + base[7], 16) / 255)), parts[0] || (parts[0] = 0), 
+        parts[1] || (parts[1] = 0), parts[2] || (parts[2] = 0);
     } else {
-        if (!(m_parts = /^((?:rgba?))\s*\(([^)]*)\)/.exec(base))) return {
-            value: base,
+        if (!(m = /^((?:rgba?))\s*\(([^)]*)\)/.exec(cstr))) return {
+            value: cstr,
             alpha
         };
-        alpha = (m_parts = (m_parts = m_parts[2].trim().split(/\s*[,/]\s*|\s+/)).map((v, i) => "%" === v[v.length - 1] ? (v = parseFloat(v) / 100, 
-        3 === i ? v : 255 * v) : "none" === v ? 0 : parseFloat(v))).length > 3 ? m_parts.pop() : 1;
+        {
+            let dims = 3;
+            parts = m[2].trim().split(/\s*[,/]\s*|\s+/), parts = parts.map((x, i) => {
+                if ("%" === x[x.length - 1]) {
+                    let v = parseFloat(x) / 100;
+                    return 3 === i ? v : 255 * v;
+                }
+                return "none" === x ? 0 : parseFloat(x);
+            }), alpha = parts.length > dims ? parts.pop() : 1;
+        }
     }
     return {
-        value: "#" + m_parts.map(v => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join(""),
+        value: "#" + parts.map(v => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join(""),
         alpha: Math.max(0, Math.min(1, alpha))
     };
 }
@@ -618,76 +631,78 @@ class QRSVG {
     get height() {
         return this.options.height;
     }
-    async drawQR(qr_size) {
-        let count = qr_size.getModuleCount();
-        var alignment_maxWidth_typeNumber = parseInt(((count - 17) / 4).toFixed(0), 10);
-        let dotSize = this.options.dotsOptions.size, drawImageSize = {
+    async drawQR(qr) {
+        let count = qr.getModuleCount(), typeNumber = parseInt(((count - 17) / 4).toFixed(0), 10), dotSize = this.options.dotsOptions.size, drawImageSize = {
             hideXDots: 0,
             hideYDots: 0,
             width: 0,
             height: 0
         };
-        if (this.qr = qr_size, this.options.image) {
-            qr_size = await this.imageTools.getSize(this.options.image, this.options.imageOptions.crossOrigin);
-            let {imageOptions, errorCorrectionPercent} = this.options;
+        if (this.qr = qr, this.options.image) {
+            let size = await this.imageTools.getSize(this.options.image, this.options.imageOptions.crossOrigin), {imageOptions, errorCorrectionPercent} = this.options;
             if (imageOptions.mode == ImageMode.background) {
-                var coverLevel_margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0;
-                alignment_maxWidth_typeNumber = (this.options.width - 2 * coverLevel_margin * dotSize) * imageOptions.imageSize, 
-                coverLevel_margin = (this.options.height - 2 * coverLevel_margin * dotSize) * imageOptions.imageSize;
-                let {width, height} = qr_size;
-                height = height / width * alignment_maxWidth_typeNumber, width = alignment_maxWidth_typeNumber, 
-                height > coverLevel_margin && (width = width / height * coverLevel_margin, height = coverLevel_margin), 
-                drawImageSize = {
+                let margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0, maxWidth = (this.options.width - 2 * margin * dotSize) * imageOptions.imageSize, maxHeight = (this.options.height - 2 * margin * dotSize) * imageOptions.imageSize, {width, height} = size;
+                height = height / width * maxWidth, width = maxWidth, height > maxHeight && (width = width / height * maxHeight, 
+                height = maxHeight), drawImageSize = {
                     hideXDots: 0,
                     hideYDots: 0,
                     width,
                     height
                 };
-            } else coverLevel_margin = imageOptions.imageSize * errorCorrectionPercent, alignment_maxWidth_typeNumber = QRUtil.getPatternPosition(alignment_maxWidth_typeNumber), 
-            drawImageSize = function({originalHeight, originalWidth, maxHiddenDots: JSCompiler_object_inline_x_16_hideMax_maxHiddenDots, maxHiddenAxisDots: JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper, dotSize, margin}) {
-                if (originalHeight <= 0 || originalWidth <= 0 || JSCompiler_object_inline_x_16_hideMax_maxHiddenDots <= 0 || dotSize <= 0 || 4 * margin ** 2 > JSCompiler_object_inline_x_16_hideMax_maxHiddenDots) return {
-                    height: 0,
-                    width: 0,
-                    hideYDots: 0,
-                    hideXDots: 0
-                };
-                JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper && JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper % 2 == 0 && (JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = Math.max(1, JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper - 1));
-                var JSCompiler_object_inline_x_14_dimMax = Math.max(originalWidth, originalHeight), JSCompiler_object_inline_y_15_dimMin_hideMin = Math.min(originalWidth, originalHeight), lower = 0;
-                JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = (JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper || JSCompiler_object_inline_x_16_hideMax_maxHiddenDots) - 2 * margin;
-                do {
-                    let newSize = lower + (JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper - lower) / 2, dotsMax = Math.max(1, Math.ceil(newSize + 2 * margin));
-                    dotsMax % 2 == 0 && dotsMax++;
-                    let dotsMin = Math.max(1, Math.ceil(newSize * JSCompiler_object_inline_y_15_dimMin_hideMin / JSCompiler_object_inline_x_14_dimMax + 2 * margin));
-                    dotsMin % 2 == 0 && dotsMin++, dotsMax * dotsMin > JSCompiler_object_inline_x_16_hideMax_maxHiddenDots ? JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = newSize : lower = newSize;
-                } while (Math.abs(lower - JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper) > .001);
-                return (JSCompiler_object_inline_x_16_hideMax_maxHiddenDots = Math.max(1, Math.ceil(lower + 2 * margin))) % 2 == 0 && JSCompiler_object_inline_x_16_hideMax_maxHiddenDots++, 
-                (JSCompiler_object_inline_y_15_dimMin_hideMin = Math.max(1, Math.ceil(lower * JSCompiler_object_inline_y_15_dimMin_hideMin / JSCompiler_object_inline_x_14_dimMax + 2 * margin))) % 2 == 0 && JSCompiler_object_inline_y_15_dimMin_hideMin++, 
-                originalWidth > originalHeight ? JSCompiler_object_inline_x_14_dimMax = JSCompiler_object_inline_x_16_hideMax_maxHiddenDots : (JSCompiler_object_inline_x_14_dimMax = JSCompiler_object_inline_y_15_dimMin_hideMin, 
-                JSCompiler_object_inline_y_15_dimMin_hideMin = JSCompiler_object_inline_x_16_hideMax_maxHiddenDots), 
-                JSCompiler_object_inline_x_16_hideMax_maxHiddenDots = JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = (JSCompiler_object_inline_x_14_dimMax - 2 * margin) * dotSize, 
-                (JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper * originalHeight / originalWidth) > (lower = (JSCompiler_object_inline_y_15_dimMin_hideMin - 2 * margin) * dotSize) && (JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper = lower, 
-                JSCompiler_object_inline_x_16_hideMax_maxHiddenDots = lower * originalWidth / originalHeight), 
-                {
-                    height: Math.round(JSCompiler_object_inline_y_17_maxHiddenAxisDots_maxW_upper + 2 * margin * dotSize),
-                    width: Math.round(JSCompiler_object_inline_x_16_hideMax_maxHiddenDots + 2 * margin * dotSize),
-                    hideYDots: JSCompiler_object_inline_y_15_dimMin_hideMin,
-                    hideXDots: JSCompiler_object_inline_x_14_dimMax
-                };
-            }({
-                originalWidth: qr_size.width,
-                originalHeight: qr_size.height,
-                maxHiddenDots: Math.floor(coverLevel_margin * (count * count - 192 - 2 * (count - 16) - alignment_maxWidth_typeNumber.length ** 2 * 25)),
-                maxHiddenAxisDots: count - 14,
-                dotSize,
-                margin: imageOptions.margin
-            });
+            } else {
+                let coverLevel = imageOptions.imageSize * errorCorrectionPercent, alignment = QRUtil.getPatternPosition(typeNumber), maxHiddenDots = Math.floor(coverLevel * (count * count - 192 - 2 * (count - 16) - alignment.length ** 2 * 25));
+                drawImageSize = function({originalHeight, originalWidth, maxHiddenDots, maxHiddenAxisDots, dotSize, margin}) {
+                    let hideDots = {
+                        x: 0,
+                        y: 0
+                    }, imageSize = {
+                        x: 0,
+                        y: 0
+                    };
+                    if (originalHeight <= 0 || originalWidth <= 0 || maxHiddenDots <= 0 || dotSize <= 0 || 4 * margin ** 2 > maxHiddenDots) return {
+                        height: 0,
+                        width: 0,
+                        hideYDots: 0,
+                        hideXDots: 0
+                    };
+                    maxHiddenAxisDots && maxHiddenAxisDots % 2 == 0 && (maxHiddenAxisDots = Math.max(1, maxHiddenAxisDots - 1));
+                    let dimMax = Math.max(originalWidth, originalHeight), dimMin = Math.min(originalWidth, originalHeight), lower = 0, upper = (maxHiddenAxisDots || maxHiddenDots) - 2 * margin;
+                    do {
+                        let newSize = lower + (upper - lower) / 2, dotsMax = Math.max(1, Math.ceil(newSize + 2 * margin));
+                        dotsMax % 2 == 0 && dotsMax++;
+                        let dotsMin = Math.max(1, Math.ceil(newSize * dimMin / dimMax + 2 * margin));
+                        dotsMin % 2 == 0 && dotsMin++, dotsMax * dotsMin > maxHiddenDots ? upper = newSize : lower = newSize;
+                    } while (Math.abs(lower - upper) > .001);
+                    let size = lower, hideMax = Math.max(1, Math.ceil(size + 2 * margin));
+                    hideMax % 2 == 0 && hideMax++;
+                    let hideMin = Math.max(1, Math.ceil(size * dimMin / dimMax + 2 * margin));
+                    hideMin % 2 == 0 && hideMin++, originalWidth > originalHeight ? (hideDots.x = hideMax, 
+                    hideDots.y = hideMin) : (hideDots.x = hideMin, hideDots.y = hideMax);
+                    let maxW = (hideDots.x - 2 * margin) * dotSize, maxH = (hideDots.y - 2 * margin) * dotSize;
+                    return imageSize.x = maxW, imageSize.y = maxW * originalHeight / originalWidth, 
+                    imageSize.y > maxH && (imageSize.y = maxH, imageSize.x = maxH * originalWidth / originalHeight), 
+                    {
+                        height: Math.round(imageSize.y + 2 * margin * dotSize),
+                        width: Math.round(imageSize.x + 2 * margin * dotSize),
+                        hideYDots: hideDots.y,
+                        hideXDots: hideDots.x
+                    };
+                }({
+                    originalWidth: size.width,
+                    originalHeight: size.height,
+                    maxHiddenDots,
+                    maxHiddenAxisDots: count - 14,
+                    dotSize,
+                    margin: imageOptions.margin
+                });
+            }
         }
         this.drawBackground(), this.options.imageOptions.mode != ImageMode.overlay && this.options.image && drawImageSize.width > 0 && drawImageSize.height > 0 && await this.drawImage({
             width: drawImageSize.width,
             height: drawImageSize.height,
             count,
             dotSize
-        }), this.drawDots((i, j) => !(this.options.imageOptions.mode == ImageMode.center && i >= (count - drawImageSize.hideXDots) / 2 && i < (count + drawImageSize.hideXDots) / 2 && j >= (count - drawImageSize.hideYDots) / 2 && j < (count + drawImageSize.hideYDots) / 2 || i < 8 && j < 8 || i >= count - 8 && j < 8 || j >= count - 8 && i < 8)), 
+        }), this.drawDots((i, j) => !(this.options.imageOptions.mode == ImageMode.center && i >= (count - drawImageSize.hideXDots) / 2 && i < (count + drawImageSize.hideXDots) / 2 && j >= (count - drawImageSize.hideYDots) / 2 && j < (count + drawImageSize.hideYDots) / 2) && !(i < 8 && j < 8 || i >= count - 8 && j < 8 || j >= count - 8 && i < 8)), 
         this.options.imageOptions.mode == ImageMode.overlay && this.options.image && drawImageSize.width > 0 && drawImageSize.height > 0 && await this.drawImage({
             width: drawImageSize.width,
             height: drawImageSize.height,
@@ -698,9 +713,10 @@ class QRSVG {
     drawBackground() {
         let options = this.options;
         if (this._element && options.backgroundOptions) {
+            let gradientOptions = options.backgroundOptions.gradient, color = options.backgroundOptions.color;
             this.createColor({
-                options: options.backgroundOptions.gradient,
-                color: options.backgroundOptions.color,
+                options: gradientOptions,
+                color,
                 additionalRotation: 0,
                 x: 0,
                 y: 0,
@@ -716,149 +732,172 @@ class QRSVG {
             this.backgroundMaskGroup.appendChild(element);
         }
     }
-    drawDots(alignment) {
-        if (!this.qr) throw Error("QR code is not defined");
-        let options = this.options;
-        var count = this.qr.getModuleCount();
-        if (count > options.width || count > options.height) throw Error("The canvas is too small");
-        let dotSize = this.options.dotsOptions.size;
-        var minSize_xFakeBeginning = Math.min(options.width, options.height);
-        options.imageOptions.mode == ImageMode.background && (minSize_xFakeBeginning -= 2 * dotSize * (options.imageOptions.margin || 0));
-        var colorCount_xBeginning = Math.floor((options.width - count * dotSize) / 2), yBeginning_yFakeBeginning = Math.floor((options.height - count * dotSize) / 2);
-        let draw = getQrDotFigure(options.dotsOptions.type);
+    drawDots(filter) {
+        if (!this.qr) throw new Error("QR code is not defined");
+        let options = this.options, count = this.qr.getModuleCount();
+        if (count > options.width || count > options.height) throw new Error("The canvas is too small");
+        let dotSize = this.options.dotsOptions.size, minSize = Math.min(options.width, options.height);
+        options.imageOptions.mode == ImageMode.background && (minSize -= 2 * dotSize * (options.imageOptions.margin || 0));
+        let xBeginning = Math.floor((options.width - count * dotSize) / 2), yBeginning = Math.floor((options.height - count * dotSize) / 2), draw = getQrDotFigure(options.dotsOptions.type, options.plugins);
         [this.dotsMask, this.dotsMaskGroup] = this.createMask("mask-dot-color"), this.defs.appendChild(this.dotsMask), 
         options.imageOptions.mode == ImageMode.background && ([this.lightDotsMask, this.lightDotsMaskGroup] = this.createMask("mask-light-dot-color"), 
         this.defs.appendChild(this.lightDotsMask));
-        var fakeCount_margin = 0;
-        let additionalDots = 0;
-        fakeCount_margin = count, options.shape === ShapeType.circle ? (fakeCount_margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0, 
-        additionalDots = Math.floor((minSize_xFakeBeginning / dotSize - count - 2 * fakeCount_margin) / 2), 
-        fakeCount_margin = count + 2 * additionalDots) : options.imageOptions.mode == ImageMode.background && (additionalDots = 1, 
-        fakeCount_margin = count + 2 * additionalDots), minSize_xFakeBeginning = colorCount_xBeginning - additionalDots * dotSize, 
-        yBeginning_yFakeBeginning -= additionalDots * dotSize, colorCount_xBeginning = count + 2 * additionalDots;
-        let fakeMatrix = Array(fakeCount_margin);
-        var center_jAlign = Math.floor(fakeCount_margin / 2);
-        for (let i = 0; i < fakeCount_margin; i++) {
-            fakeMatrix[i] = Array(fakeCount_margin);
-            for (let j = 0; j < fakeCount_margin; j++) if (i > additionalDots - 1 && i < fakeCount_margin - additionalDots && j > additionalDots - 1 && j < fakeCount_margin - additionalDots) {
-                let ii = i - additionalDots, jj = j - additionalDots;
-                alignment && !alignment(ii, jj) ? fakeMatrix[i][j] = void 0 : fakeMatrix[i][j] = !!this.qr.isDark(jj, ii);
-            } else fakeMatrix[i][j] = options.shape === ShapeType.circle && Math.sqrt((i - center_jAlign) * (i - center_jAlign) + (j - center_jAlign) * (j - center_jAlign)) > center_jAlign ? void 0 : i == additionalDots - 1 || i == fakeCount_margin - additionalDots || j == additionalDots - 1 || j == fakeCount_margin - additionalDots ? (j == additionalDots - 1 && (i < additionalDots + 8 || i > fakeCount_margin - additionalDots - 9) || j == fakeCount_margin - additionalDots && i < additionalDots + 8 || i == additionalDots - 1 && (j < additionalDots + 8 || j > fakeCount_margin - additionalDots - 9) || i == fakeCount_margin - additionalDots && j < additionalDots + 8) && void 0 : this.qr.isDark(j - 2 * additionalDots < 0 ? j : j >= count ? j - 2 * additionalDots : j - additionalDots, i - 2 * additionalDots < 0 ? i : i >= count ? i - 2 * additionalDots : i - additionalDots);
+        let margin = 0, additionalDots = 0, fakeCount = count;
+        options.shape === ShapeType.circle ? (margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0, 
+        additionalDots = Math.floor((minSize / dotSize - count - 2 * margin) / 2), fakeCount = count + 2 * additionalDots) : options.imageOptions.mode == ImageMode.background && (additionalDots = 1, 
+        fakeCount = count + 2 * additionalDots);
+        let xFakeBeginning = xBeginning - additionalDots * dotSize, yFakeBeginning = yBeginning - additionalDots * dotSize, colorX = xFakeBeginning, colorY = yFakeBeginning, colorCount = count + 2 * additionalDots, fakeMatrix = new Array(fakeCount), center = Math.floor(fakeCount / 2);
+        for (let i = 0; i < fakeCount; i++) {
+            fakeMatrix[i] = new Array(fakeCount);
+            for (let j = 0; j < fakeCount; j++) {
+                if (i > additionalDots - 1 && i < fakeCount - additionalDots && j > additionalDots - 1 && j < fakeCount - additionalDots) {
+                    let ii = i - additionalDots, jj = j - additionalDots;
+                    filter && !filter(ii, jj) ? fakeMatrix[i][j] = void 0 : fakeMatrix[i][j] = !!this.qr.isDark(jj, ii);
+                    continue;
+                }
+                options.shape === ShapeType.circle && Math.sqrt((i - center) * (i - center) + (j - center) * (j - center)) > center ? fakeMatrix[i][j] = void 0 : fakeMatrix[i][j] = i != additionalDots - 1 && i != fakeCount - additionalDots && j != additionalDots - 1 && j != fakeCount - additionalDots ? this.qr.isDark(j - 2 * additionalDots < 0 ? j : j >= count ? j - 2 * additionalDots : j - additionalDots, i - 2 * additionalDots < 0 ? i : i >= count ? i - 2 * additionalDots : i - additionalDots) : (j == additionalDots - 1 && (i < additionalDots + 8 || i > fakeCount - additionalDots - 9) || j == fakeCount - additionalDots && i < additionalDots + 8 || i == additionalDots - 1 && (j < additionalDots + 8 || j > fakeCount - additionalDots - 9) || i == fakeCount - additionalDots && j < additionalDots + 8) && void 0;
+            }
         }
-        alignment = QRUtil.getPatternPosition((count - 17) / 4);
-        for (let i = 0; i < fakeCount_margin; i++) {
-            count = alignment.find(v => i - additionalDots > v - 3 && i - additionalDots < v + 3);
-            for (let j = 0; j < fakeCount_margin; j++) center_jAlign = alignment.find(v => j - additionalDots > v - 3 && j - additionalDots < v + 3), 
-            null != fakeMatrix[i][j] && (this.lightDotsMask && (draw = count && center_jAlign && (count != alignment[0] && center_jAlign != alignment[0] || center_jAlign != alignment[0] && center_jAlign != alignment[alignment.length - 1] || count != alignment[0] && count != alignment[alignment.length - 1]) ? getQrDotFigure(DotType.square) : getQrDotFigure(DotType.tinySquare)), 
-            fakeMatrix[i][j] ? this.dotsMaskGroup && this.dotsMaskGroup.appendChild(draw({
-                x: minSize_xFakeBeginning + i * dotSize,
-                y: yBeginning_yFakeBeginning + j * dotSize,
-                size: dotSize,
-                document: this.options.document,
-                getNeighbor: (xOffset, yOffset) => !0 === fakeMatrix[i + xOffset]?.[j + yOffset]
-            })) : this.lightDotsMask && this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(draw({
-                x: minSize_xFakeBeginning + i * dotSize,
-                y: yBeginning_yFakeBeginning + j * dotSize,
-                size: dotSize,
-                document: this.options.document,
-                getNeighbor: (xOffset, yOffset) => !1 === fakeMatrix[i + xOffset]?.[j + yOffset]
-            })));
+        let typeNr = (count - 17) / 4, alignment = QRUtil.getPatternPosition(typeNr);
+        for (let i = 0; i < fakeCount; i++) {
+            let iAlign = alignment.find(v => i - additionalDots > v - 3 && i - additionalDots < v + 3);
+            for (let j = 0; j < fakeCount; j++) {
+                let jAlign = alignment.find(v => j - additionalDots > v - 3 && j - additionalDots < v + 3);
+                null != fakeMatrix[i][j] && (this.lightDotsMask && (draw = iAlign && jAlign && (iAlign != alignment[0] && jAlign != alignment[0] || jAlign != alignment[0] && jAlign != alignment[alignment.length - 1] || iAlign != alignment[0] && iAlign != alignment[alignment.length - 1]) ? getQrDotFigure(DotType.square) : getQrDotFigure(DotType.tinySquare)), 
+                fakeMatrix[i][j] ? this.dotsMaskGroup && this.dotsMaskGroup.appendChild(draw({
+                    x: xFakeBeginning + i * dotSize,
+                    y: yFakeBeginning + j * dotSize,
+                    size: dotSize,
+                    document: this.options.document,
+                    getNeighbor: (xOffset, yOffset) => !0 === fakeMatrix[i + xOffset]?.[j + yOffset]
+                })) : this.lightDotsMask && this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(draw({
+                    x: xFakeBeginning + i * dotSize,
+                    y: yFakeBeginning + j * dotSize,
+                    size: dotSize,
+                    document: this.options.document,
+                    getNeighbor: (xOffset, yOffset) => !1 === fakeMatrix[i + xOffset]?.[j + yOffset]
+                })));
+            }
         }
         this.lightDotsMask && this.createColor({
             options: options.imageOptions.fill.gradient,
             color: options.imageOptions.fill.color,
             additionalRotation: 0,
-            x: minSize_xFakeBeginning,
-            y: yBeginning_yFakeBeginning,
-            height: colorCount_xBeginning * dotSize,
-            width: colorCount_xBeginning * dotSize,
+            x: colorX,
+            y: colorY,
+            height: colorCount * dotSize,
+            width: colorCount * dotSize,
             name: "light-dot-color"
         }), this.createColor({
             options: options.dotsOptions?.gradient,
             color: options.dotsOptions.color,
             additionalRotation: 0,
-            x: minSize_xFakeBeginning,
-            y: yBeginning_yFakeBeginning,
-            height: colorCount_xBeginning * dotSize,
-            width: colorCount_xBeginning * dotSize,
+            x: colorX,
+            y: colorY,
+            height: colorCount * dotSize,
+            width: colorCount * dotSize,
             name: "dot-color"
         });
     }
     drawCorners() {
-        if (!this.qr) throw Error("QR code is not defined");
-        let options = this.options;
-        if (!this._element) throw Error("Element code is not defined");
+        if (!this.qr) throw new Error("QR code is not defined");
+        let element = this._element, options = this.options;
+        if (!element) throw new Error("Element code is not defined");
         let count = this.qr.getModuleCount(), dotSize = this.options.dotsOptions.size, cornersSquareSize = 7 * dotSize, cornersDotSize = 3 * dotSize, xBeginning = Math.floor((options.width - count * dotSize) / 2), yBeginning = Math.floor((options.height - count * dotSize) / 2);
-        [ [ 0, 0, 0 ], [ 1, 0, Math.PI / 2 ], [ 0, 1, -Math.PI / 2 ] ].forEach(([column_draw, row, draw]) => {
-            let x = xBeginning + column_draw * dotSize * (count - 7), y = yBeginning + row * dotSize * (count - 7);
-            var cornersDotMaskGroup_cornersSquareMask = this.dotsMask;
-            let cornersSquareMaskGroup = this.dotsMaskGroup;
-            var val, cornersDotMask_draw = this.dotsMask;
-            if (cornersDotMaskGroup_cornersSquareMask = this.dotsMaskGroup, (options.cornersSquareOptions?.gradient || options.cornersSquareOptions?.color) && ([cornersDotMaskGroup_cornersSquareMask, cornersSquareMaskGroup] = this.createMask(`mask-corners-square-color-${column_draw}-${row}`), 
-            this.defs.appendChild(cornersDotMaskGroup_cornersSquareMask), cornersDotMask_draw = cornersDotMaskGroup_cornersSquareMask, 
-            cornersDotMaskGroup_cornersSquareMask = cornersSquareMaskGroup, this.createColor({
+        [ [ 0, 0, 0 ], [ 1, 0, Math.PI / 2 ], [ 0, 1, -Math.PI / 2 ] ].forEach(([column, row, rotation]) => {
+            let x = xBeginning + column * dotSize * (count - 7), y = yBeginning + row * dotSize * (count - 7), cornersSquareMask = this.dotsMask, cornersSquareMaskGroup = this.dotsMaskGroup, cornersDotMask = this.dotsMask, cornersDotMaskGroup = this.dotsMaskGroup;
+            (options.cornersSquareOptions?.gradient || options.cornersSquareOptions?.color) && ([cornersSquareMask, cornersSquareMaskGroup] = this.createMask(`mask-corners-square-color-${column}-${row}`), 
+            this.defs.appendChild(cornersSquareMask), cornersDotMask = cornersSquareMask, cornersDotMaskGroup = cornersSquareMaskGroup, 
+            this.createColor({
                 options: options.cornersSquareOptions?.gradient,
                 color: options.cornersSquareOptions?.color,
-                additionalRotation: draw,
+                additionalRotation: rotation,
                 x,
                 y,
                 height: cornersSquareSize,
                 width: cornersSquareSize,
-                name: `corners-square-color-${column_draw}-${row}`
-            })), val = options.cornersSquareOptions?.type, val && cornerSquareTypes.has(val)) {
-                let [cornerElement, cornerFill] = (qrCornerSquareFigures[options.cornersSquareOptions.type] || qrCornerSquareFigures[CornerSquareType.square])({
-                    x,
-                    y,
-                    size: cornersSquareSize,
-                    document: this.options.document,
-                    rotation: draw
-                });
+                name: `corners-square-color-${column}-${row}`
+            }));
+            let squareArgs = {
+                x,
+                y,
+                size: cornersSquareSize,
+                document: this.options.document,
+                rotation
+            }, pluinCornerSquare = options.plugins?.length ? (plugins = options.plugins, args => {
+                for (let plugin of plugins) {
+                    let el = plugin.drawCornerSquare?.(args);
+                    if (el) return el;
+                }
+            })(squareArgs) : void 0;
+            var plugins, type, val;
+            if (pluinCornerSquare) {
+                let [cornerElement, cornerFill] = pluinCornerSquare;
+                cornersSquareMaskGroup && cornersSquareMaskGroup.appendChild(cornerElement), this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(cornerFill);
+            } else if (val = options.cornersSquareOptions?.type, val && cornerSquareTypes.has(val)) {
+                let draw = (type = options.cornersSquareOptions.type, qrCornerSquareFigures[type] || qrCornerSquareFigures[CornerSquareType.square]), [cornerElement, cornerFill] = draw(squareArgs);
                 cornersSquareMaskGroup && cornersSquareMaskGroup.appendChild(cornerElement), this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(cornerFill);
             } else {
-                cornersDotMask_draw = getQrDotFigure(options.cornersSquareOptions?.type || options.dotsOptions.type);
-                for (let i = 0; i < squareMask.length; i++) for (let j = 0; j < squareMask[i].length; j++) squareMask[i]?.[j] ? cornersSquareMaskGroup && cornersSquareMaskGroup.appendChild(cornersDotMask_draw({
+                let draw = getQrDotFigure(options.cornersSquareOptions?.type || options.dotsOptions.type, options.plugins);
+                for (let i = 0; i < squareMask.length; i++) for (let j = 0; j < squareMask[i].length; j++) squareMask[i]?.[j] ? cornersSquareMaskGroup && cornersSquareMaskGroup.appendChild(draw({
                     x: x + i * dotSize,
                     y: y + j * dotSize,
                     size: dotSize,
                     document: this.options.document,
                     getNeighbor: (xOffset, yOffset) => !!squareMask[i + xOffset]?.[j + yOffset]
-                })) : this.lightDotsMask && !dotMask[i]?.[j] && this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(cornersDotMask_draw({
+                })) : this.lightDotsMask && !dotMask[i]?.[j] && this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(draw({
                     x: x + i * dotSize,
                     y: y + j * dotSize,
                     size: dotSize,
                     document: this.options.document,
                     getNeighbor: (xOffset, yOffset) => !squareMask[i + xOffset]?.[j + yOffset] && !dotMask[i + xOffset]?.[j + yOffset]
                 }));
-                if (this.lightDotsMask) for (let i = -1; i < 8; i++) for (let j = -1; j < 8; j++) (-1 == i || 7 == i || -1 == j || 7 == j) && this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(cornersDotMask_draw({
+                if (this.lightDotsMask) for (let i = -1; i < 8; i++) for (let j = -1; j < 8; j++) -1 != i && 7 != i && -1 != j && 7 != j || this.lightDotsMaskGroup && this.lightDotsMaskGroup.appendChild(draw({
                     x: x + i * dotSize,
                     y: y + j * dotSize,
                     size: dotSize,
                     document: this.options.document,
-                    getNeighbor: (ii, jj) => (jj = j + jj, (ii = i + ii) >= -1 && ii <= 7 && jj >= -1 && jj <= 7 && (-1 == ii || 7 == ii || -1 == jj || 7 == jj))
+                    getNeighbor: (xOffset, yOffset) => {
+                        let ii = i + xOffset, jj = j + yOffset;
+                        return ii >= -1 && ii <= 7 && jj >= -1 && jj <= 7 && (-1 == ii || 7 == ii || -1 == jj || 7 == jj);
+                    }
                 }));
             }
-            if ((options.cornersDotOptions?.gradient || options.cornersDotOptions?.color) && ([cornersDotMask_draw, cornersDotMaskGroup_cornersSquareMask] = this.createMask(`mask-corners-dot-color-${column_draw}-${row}`), 
-            this.defs.appendChild(cornersDotMask_draw), this.createColor({
+            (options.cornersDotOptions?.gradient || options.cornersDotOptions?.color) && ([cornersDotMask, cornersDotMaskGroup] = this.createMask(`mask-corners-dot-color-${column}-${row}`), 
+            this.defs.appendChild(cornersDotMask), this.createColor({
                 options: options.cornersDotOptions?.gradient,
                 color: options.cornersDotOptions?.color,
-                additionalRotation: draw,
+                additionalRotation: rotation,
                 x: x + 2 * dotSize,
                 y: y + 2 * dotSize,
                 height: cornersDotSize,
                 width: cornersDotSize,
-                name: `corners-dot-color-${column_draw}-${row}`
-            })), function(val) {
-                return !(!val || !cornerDotTypes.has(val));
-            }(options.cornersDotOptions?.type)) column_draw = qrCornerDotFigures[options.cornersDotOptions.type] || qrCornerDotFigures[CornerDotType.square], 
-            cornersDotMaskGroup_cornersSquareMask && cornersDotMaskGroup_cornersSquareMask.appendChild(column_draw({
+                name: `corners-dot-color-${column}-${row}`
+            }));
+            let dotArgs = {
                 x: x + 2 * dotSize,
                 y: y + 2 * dotSize,
                 size: cornersDotSize,
                 document: this.document,
-                rotation: draw
-            })); else {
-                draw = getQrDotFigure(options.cornersDotOptions?.type || options.dotsOptions.type);
-                for (let i = 0; i < dotMask.length; i++) for (let j = 0; j < dotMask[i].length; j++) dotMask[i]?.[j] && cornersDotMaskGroup_cornersSquareMask && cornersDotMaskGroup_cornersSquareMask.appendChild(draw({
+                rotation
+            }, pluinCornerDot = options.plugins?.length ? function(plugins) {
+                return args => {
+                    for (let plugin of plugins) {
+                        let el = plugin.drawCornerDot?.(args);
+                        if (el) return el;
+                    }
+                };
+            }(options.plugins)(dotArgs) : void 0;
+            if (pluinCornerDot) cornersDotMaskGroup && cornersDotMaskGroup.appendChild(pluinCornerDot); else if (function(val) {
+                return !(!val || !cornerDotTypes.has(val));
+            }(options.cornersDotOptions?.type)) {
+                let draw = function(type) {
+                    return qrCornerDotFigures[type] || qrCornerDotFigures[CornerDotType.square];
+                }(options.cornersDotOptions.type);
+                cornersDotMaskGroup && cornersDotMaskGroup.appendChild(draw(dotArgs));
+            } else {
+                let draw = getQrDotFigure(options.cornersDotOptions?.type || options.dotsOptions.type, options.plugins);
+                for (let i = 0; i < dotMask.length; i++) for (let j = 0; j < dotMask[i].length; j++) dotMask[i]?.[j] && cornersDotMaskGroup && cornersDotMaskGroup.appendChild(draw({
                     x: x + i * dotSize,
                     y: y + j * dotSize,
                     size: dotSize,
@@ -868,24 +907,25 @@ class QRSVG {
             }
         });
     }
-    async drawImage({width: dw_width, height: dh_height, count, dotSize}) {
-        var image = this.options, dx = Math.floor((image.width - count * dotSize) / 2), encoding = Math.floor((image.height - count * dotSize) / 2), container_data = image.imageOptions.margin * dotSize;
-        if (image.imageOptions.mode == ImageMode.background && (container_data = 0), dx = dx + container_data + (count * dotSize - dw_width) / 2, 
-        count = encoding + container_data + (count * dotSize - dh_height) / 2, dw_width -= 2 * container_data, 
-        dh_height -= 2 * container_data, container_data = await this.imageTools.toDataURL(image.image || ""), 
-        (image = this.document.createElementNS("http://www.w3.org/2000/svg", "image")).setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", container_data || ""), 
-        container_data.startsWith("data:image/svg+xml;")) {
-            if (dotSize = (container_data = container_data.substring(19)).indexOf(","), encoding = container_data.substring(0, dotSize), 
-            container_data = container_data.substring(dotSize + 1), "base64" === encoding) container_data = "function" == typeof atob ? atob(container_data) : Buffer.from(container_data, "base64").toString("utf8"); else container_data = "";
-            container_data && (container_data = (new DOMParser).parseFromString(container_data, "text/xml"), 
-            (container_data = Array.from(container_data.getElementsByTagName("svg"))).length && (image = container_data[0]).setAttribute("overflow", "visible"));
+    async drawImage({width, height, count, dotSize}) {
+        let options = this.options, xBeginning = Math.floor((options.width - count * dotSize) / 2), yBeginning = Math.floor((options.height - count * dotSize) / 2), margin = options.imageOptions.margin * dotSize;
+        options.imageOptions.mode == ImageMode.background && (margin = 0);
+        let dx = xBeginning + margin + (count * dotSize - width) / 2, dy = yBeginning + margin + (count * dotSize - height) / 2, dw = width - 2 * margin, dh = height - 2 * margin, imageUrl = await this.imageTools.toDataURL(options.image || ""), image = this.document.createElementNS("http://www.w3.org/2000/svg", "image");
+        if (image.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", imageUrl || ""), 
+        imageUrl.startsWith("data:image/svg+xml;")) {
+            let data = imageUrl.substring(19), i = data.indexOf(","), encoding = data.substring(0, i);
+            if (data = data.substring(i + 1), "base64" === encoding) data = "function" == typeof atob ? atob(data) : Buffer.from(data, "base64").toString("utf8"); else data = "";
+            if (data) {
+                let container = (new DOMParser).parseFromString(data, "text/xml"), rootEl = Array.from(container.getElementsByTagName("svg"));
+                rootEl.length && (image = rootEl[0], image.setAttribute("overflow", "visible"));
+            }
         }
-        image.setAttribute("x", numToAttr(dx)), image.setAttribute("y", numToAttr(count)), 
-        image.setAttribute("width", `${numToAttr(dw_width)}px`), image.setAttribute("height", `${numToAttr(dh_height)}px`), 
+        image.setAttribute("x", numToAttr(dx)), image.setAttribute("y", numToAttr(dy)), 
+        image.setAttribute("width", `${numToAttr(dw)}px`), image.setAttribute("height", `${numToAttr(dh)}px`), 
         this._element.appendChild(image);
     }
-    createColor({options, color, additionalRotation: additionalRotation_positiveRotation, x, y, height, width, name}) {
-        var gradientSize_x0 = width > height ? width : height;
+    createColor({options, color, additionalRotation, x, y, height, width, name}) {
+        let gradientSize = width > height ? width : height;
         x -= this.options.dotsOptions.size, y -= this.options.dotsOptions.size, width += 2 * this.options.dotsOptions.size, 
         height += 2 * this.options.dotsOptions.size;
         let rect = this.document.createElementNS("http://www.w3.org/2000/svg", "rect");
@@ -897,35 +937,38 @@ class QRSVG {
             gradient.setAttribute("id", name), gradient.setAttribute("gradientUnits", "userSpaceOnUse"), 
             gradient.setAttribute("fx", numToAttr(x + width / 2)), gradient.setAttribute("fy", numToAttr(y + height / 2)), 
             gradient.setAttribute("cx", numToAttr(x + width / 2)), gradient.setAttribute("cy", numToAttr(y + height / 2)), 
-            gradient.setAttribute("r", numToAttr(gradientSize_x0 / 2)); else {
-                gradientSize_x0 = x + width / 2;
-                let y0 = y + height / 2;
-                x += width / 2, y += height / 2, (additionalRotation_positiveRotation = ((color = ((options.rotation || 0) + additionalRotation_positiveRotation) % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI)) >= 0 && additionalRotation_positiveRotation <= .25 * Math.PI || additionalRotation_positiveRotation > 1.75 * Math.PI && additionalRotation_positiveRotation <= 2 * Math.PI ? (gradientSize_x0 -= width / 2, 
-                y0 -= height / 2 * Math.tan(color), x += width / 2, y += height / 2 * Math.tan(color)) : additionalRotation_positiveRotation > .25 * Math.PI && additionalRotation_positiveRotation <= .75 * Math.PI ? (y0 -= height / 2, 
-                gradientSize_x0 -= width / 2 / Math.tan(color), y += height / 2, x += width / 2 / Math.tan(color)) : additionalRotation_positiveRotation > .75 * Math.PI && additionalRotation_positiveRotation <= 1.25 * Math.PI ? (gradientSize_x0 += width / 2, 
-                y0 += height / 2 * Math.tan(color), x -= width / 2, y -= height / 2 * Math.tan(color)) : additionalRotation_positiveRotation > 1.25 * Math.PI && additionalRotation_positiveRotation <= 1.75 * Math.PI && (y0 += height / 2, 
-                gradientSize_x0 += width / 2 / Math.tan(color), y -= height / 2, x -= width / 2 / Math.tan(color)), 
+            gradient.setAttribute("r", numToAttr(gradientSize / 2)); else {
+                let rotation = ((options.rotation || 0) + additionalRotation) % (2 * Math.PI), positiveRotation = (rotation + 2 * Math.PI) % (2 * Math.PI), x0 = x + width / 2, y0 = y + height / 2, x1 = x + width / 2, y1 = y + height / 2;
+                positiveRotation >= 0 && positiveRotation <= .25 * Math.PI || positiveRotation > 1.75 * Math.PI && positiveRotation <= 2 * Math.PI ? (x0 -= width / 2, 
+                y0 -= height / 2 * Math.tan(rotation), x1 += width / 2, y1 += height / 2 * Math.tan(rotation)) : positiveRotation > .25 * Math.PI && positiveRotation <= .75 * Math.PI ? (y0 -= height / 2, 
+                x0 -= width / 2 / Math.tan(rotation), y1 += height / 2, x1 += width / 2 / Math.tan(rotation)) : positiveRotation > .75 * Math.PI && positiveRotation <= 1.25 * Math.PI ? (x0 += width / 2, 
+                y0 += height / 2 * Math.tan(rotation), x1 -= width / 2, y1 -= height / 2 * Math.tan(rotation)) : positiveRotation > 1.25 * Math.PI && positiveRotation <= 1.75 * Math.PI && (y0 += height / 2, 
+                x0 += width / 2 / Math.tan(rotation), y1 -= height / 2, x1 -= width / 2 / Math.tan(rotation)), 
                 gradient = this.document.createElementNS("http://www.w3.org/2000/svg", "linearGradient"), 
                 gradient.setAttribute("id", name), gradient.setAttribute("gradientUnits", "userSpaceOnUse"), 
-                gradient.setAttribute("x1", numToAttr(gradientSize_x0)), gradient.setAttribute("y1", numToAttr(y0)), 
-                gradient.setAttribute("x2", numToAttr(x)), gradient.setAttribute("y2", numToAttr(y));
+                gradient.setAttribute("x1", numToAttr(x0)), gradient.setAttribute("y1", numToAttr(y0)), 
+                gradient.setAttribute("x2", numToAttr(x1)), gradient.setAttribute("y2", numToAttr(y1));
             }
-            options.colorStops.forEach(parsed_stopCfg => {
+            options.colorStops.forEach(stopCfg => {
                 let stop = this.document.createElementNS("http://www.w3.org/2000/svg", "stop");
-                stop.setAttribute("offset", `${numToAttr(100 * parsed_stopCfg.offset)}%`), parsed_stopCfg = parseColor(parsed_stopCfg.color), 
-                stop.setAttribute("stop-color", parsed_stopCfg.value), parsed_stopCfg.alpha < 1 && stop.setAttribute("stop-opacity", parsed_stopCfg.alpha.toFixed(7)), 
+                stop.setAttribute("offset", `${numToAttr(100 * stopCfg.offset)}%`);
+                let parsed = parseColor(stopCfg.color);
+                stop.setAttribute("stop-color", parsed.value), parsed.alpha < 1 && stop.setAttribute("stop-opacity", parsed.alpha.toFixed(7)), 
                 gradient.appendChild(stop);
             }), rect.setAttribute("fill", `url(#${name})`), this.defs.appendChild(gradient);
-        } else color && (options = parseColor(color), rect.setAttribute("fill", options.value), 
-        options.alpha < 1 && rect.setAttribute("opacity", options.alpha.toFixed(7)));
+        } else if (color) {
+            let parsed = parseColor(color);
+            rect.setAttribute("fill", parsed.value), parsed.alpha < 1 && rect.setAttribute("opacity", parsed.alpha.toFixed(7));
+        }
         this._element.appendChild(rect);
     }
-    createMask(group_id) {
+    createMask(id) {
         let options = this.options, mask = this.document.createElementNS("http://www.w3.org/2000/svg", "mask");
-        return mask.setAttribute("id", group_id), mask.setAttribute("maskUnits", "userSpaceOnUse"), 
-        mask.setAttribute("x", "0"), mask.setAttribute("y", "0"), mask.setAttribute("width", numToAttr(options.width)), 
-        mask.setAttribute("height", numToAttr(options.height)), (group_id = this.document.createElementNS("http://www.w3.org/2000/svg", "g")).setAttribute("fill", "#fff"), 
-        mask.appendChild(group_id), [ mask, group_id ];
+        mask.setAttribute("id", id), mask.setAttribute("maskUnits", "userSpaceOnUse"), mask.setAttribute("x", "0"), 
+        mask.setAttribute("y", "0"), mask.setAttribute("width", numToAttr(options.width)), 
+        mask.setAttribute("height", numToAttr(options.height));
+        let group = this.document.createElementNS("http://www.w3.org/2000/svg", "g");
+        return group.setAttribute("fill", "#fff"), mask.appendChild(group), [ mask, group ];
     }
 }
 
@@ -948,11 +991,12 @@ let QRCodeStyling$1 = class {
         this.options = options ? sanitizeOptions(mergeDeep(defaultOptions, options)) : defaultOptions, 
         this.update();
     }
-    update(mode) {
-        this.container && (this.container.innerHTML = ""), this.options = mode ? sanitizeOptions(mergeDeep(this.options, mode)) : this.options, 
-        this.options.data && (this.options.stringToBytesFuncs && (Object.assign(QRCodeMinimal.stringToBytesFuncs, this.options.stringToBytesFuncs), 
-        delete this.options.stringToBytesFuncs), this.qr = new QRCodeMinimal(this.options.qrOptions.typeNumber, this.options.qrOptions.errorCorrectionLevel), 
-        mode = this.options.qrOptions.mode || function(data) {
+    update(options) {
+        if (this.container && (this.container.innerHTML = ""), this.options = options ? sanitizeOptions(mergeDeep(this.options, options)) : this.options, 
+        !this.options.data) return;
+        this.options.stringToBytesFuncs && (Object.assign(QRCodeMinimal.stringToBytesFuncs, this.options.stringToBytesFuncs), 
+        delete this.options.stringToBytesFuncs), this.qr = new QRCodeMinimal(this.options.qrOptions.typeNumber, this.options.qrOptions.errorCorrectionLevel);
+        let mode = this.options.qrOptions.mode || function(data) {
             switch (!0) {
               case /^[0-9]*$/.test(data):
                 return Mode.numeric;
@@ -966,86 +1010,100 @@ let QRCodeStyling$1 = class {
               default:
                 return Mode.byte;
             }
-        }(this.options.data), this.qr.addData(this.options.data, mode), this.qr.make(), 
-        this.setupSvg(), this.append(this.container));
+        }(this.options.data);
+        this.qr.addData(this.options.data, mode), this.qr.make(), this.setupSvg(), this.append(this.container);
     }
     append(container) {
         container && (this.qrSVG?.element && container.appendChild(this.qrSVG.element), 
         this.container = container);
     }
     applyExtension(extension) {
-        if (!extension) throw Error("Extension function should be defined.");
+        if (!extension) throw new Error("Extension function should be defined.");
         this.extension = extension, this.update();
     }
     deleteExtension() {
         this.extension = void 0, this.update();
     }
     async serialize() {
-        if (!this.qr) throw Error("QR code is empty");
+        if (!this.qr) throw new Error("QR code is empty");
         if (this.qrSVG?.element && this.svgDrawingPromise || this.setupSvg(), await this.svgDrawingPromise, 
-        this.qrSVG?.element) return '<?xml version="1.0" standalone="no"?>\r\n' + (new XMLSerializer).serializeToString(this.qrSVG.element);
+        !this.qrSVG?.element) return;
+        let source = (new XMLSerializer).serializeToString(this.qrSVG.element);
+        return source = '<?xml version="1.0" standalone="no"?>\r\n' + source, source;
     }
     setupSvg() {
-        if (this.qr) {
-            var count = this.qr.getModuleCount();
-            this.options.imageOptions.mode == ImageMode.background && this.options.shape != ShapeType.circle && (count += 2), 
-            (count = Math.ceil((this.options.shape == ShapeType.circle ? Math.sqrt(2) : 1) * count)) % 2 == 0 && --count;
-            var margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0;
-            this.options.imageOptions.mode == ImageMode.background && (margin += this.options.imageOptions.margin || 0);
-            var size = Math.ceil(this.options.dotsOptions.size * (count + 2 * margin));
-            this.qrSVG = new QRSVG({
+        if (!this.qr) return;
+        let moduleCount = this.qr.getModuleCount();
+        this.options.imageOptions.mode == ImageMode.background && this.options.shape != ShapeType.circle && (moduleCount += 2);
+        let count = Math.ceil((this.options.shape == ShapeType.circle ? Math.sqrt(2) : 1) * moduleCount);
+        count % 2 == 0 && (count -= 1);
+        let margin = this.options.backgroundOptions && this.options.backgroundOptions.margin || 0;
+        this.options.imageOptions.mode == ImageMode.background && (margin += this.options.imageOptions.margin || 0);
+        let size = Math.ceil(this.options.dotsOptions.size * (count + 2 * margin));
+        this.qrSVG = new QRSVG({
+            ...this.options,
+            width: size,
+            height: size,
+            errorCorrectionPercent: ErrorCorrectionPercents[this.options.qrOptions.errorCorrectionLevel]
+        }), this.svgDrawingPromise = this.qrSVG.drawQR(this.qr).then(() => {
+            this.qrSVG?.element && (this.options.plugins?.forEach(plugin => plugin.postProcess?.(this.qrSVG.element, {
                 ...this.options,
                 width: size,
-                height: size,
-                errorCorrectionPercent: ErrorCorrectionPercents[this.options.qrOptions.errorCorrectionLevel]
-            }), this.svgDrawingPromise = this.qrSVG.drawQR(this.qr).then(() => {
-                this.qrSVG?.element && this.extension?.(this.qrSVG.element, {
-                    ...this.options,
-                    width: size,
-                    height: size
-                });
-            });
-        }
+                height: size
+            })), this.extension?.(this.qrSVG.element, {
+                ...this.options,
+                width: size,
+                height: size
+            }));
+        });
     }
 };
 
 var FileExtension;
 
-(FileExtension = FileExtension ||= {}).svg = "svg", FileExtension.png = "png", FileExtension.jpeg = "jpeg", 
-FileExtension.webp = "webp";
+let browserUtils;
+
+!function(FileExtension) {
+    FileExtension.svg = "svg", FileExtension.png = "png", FileExtension.jpeg = "jpeg", 
+    FileExtension.webp = "webp";
+}(FileExtension || (FileExtension = {}));
 
 class QRCodeStyling extends QRCodeStyling$1 {
     constructor(options) {
-        let dom = (new DOMImplementation).createDocument(null, ""), imageCache = new Map, loadImage = async buff => {
-            if ("string" == typeof buff) {
-                let pr = imageCache.get(buff);
-                return pr || (pr = fetch(buff).then(res => res.arrayBuffer().then(buff => Buffer.from(buff)).then(async data => ({
+        let dom = (new DOMImplementation).createDocument(null, ""), imageCache = new Map, loadImage = async url => {
+            if ("string" == typeof url) {
+                let pr = imageCache.get(url);
+                return pr || (pr = fetch(url).then(res => res.arrayBuffer().then(buff => Buffer.from(buff)).then(async data => ({
                     contentType: res.headers.get("Content-Type") || await fileTypeFromBuffer(data).then(r => r?.mime),
                     data
-                }))), imageCache.set(buff, pr), pr);
+                }))), imageCache.set(url, pr), pr);
+            }
+            {
+                const buff = Buffer.from(url);
+                return {
+                    contentType: await fileTypeFromBuffer(buff).then(r => r?.mime),
+                    data: buff
+                };
             }
-            return buff = Buffer.from(buff), {
-                contentType: await fileTypeFromBuffer(buff).then(r => r?.mime),
-                data: buff
-            };
         };
         global.XMLSerializer = XMLSerializer$1, global.DOMParser = DOMParser$1, super({
             ...options,
             document: options.document || dom,
             imageTools: options.imageTools || {
                 toDataURL: url => "string" == typeof url && url.startsWith("data:") ? Promise.resolve(url) : loadImage(url).then(({contentType, data}) => `data:${contentType?.replace("application/xml", "image/svg+xml")};base64,${data.toString("base64")}`),
-                getSize: async data => (({data} = Buffer.isBuffer(options.image) ? {
-                    data: options.image
-                } : await loadImage(data)), {
-                    width: (data = await sharp(data).metadata()).width,
-                    height: data.height
-                })
+                getSize: async src => {
+                    let {data} = Buffer.isBuffer(options.image) ? {
+                        data: options.image
+                    } : await loadImage(src), meta = await sharp(data).metadata();
+                    return {
+                        width: meta.width,
+                        height: meta.height
+                    };
+                }
             }
         });
     }
 }
 
-var browserUtils = void 0;
-
 export { CornerDotType, CornerSquareType, DotType, ErrorCorrectionPercents, FileExtension, GradientType, ImageMode, QRCodeStyling, ShapeType, browserUtils };
 //# sourceMappingURL=qr-code-styling-node.js.map