qreator 9.7.2 → 9.8.2

package/README.md

@@ -14,6 +14,8 @@ QR Code generator for browser and node.js with tree shaking and logo support
 -   supports color customization
 -   supports logos
 -   supports border-radius
+-   supports corner mode (merged rounded corners)
+-   supports finder pattern customization (shape + color)
 -   tree shaking support
 -   browser / node.js
 
@@ -47,6 +49,18 @@ const pngBuffer = await getPNG("I love QR", {
 });
 ```
 
+### Finder pattern customization
+
+```javascript
+const svgString = await getSVG("I love QR", {
+    finderOuterShape: "drop",
+    finderInnerShape: "circle",
+    finderColor: "#ff0000",
+    borderRadius: 2,
+    cornerMode: "merge",
+});
+```
+
 [More examples](./examples)
 
 ### Syntax
@@ -75,6 +89,10 @@ const pngBuffer = await getPNG("I love QR", {
 |    `color`     |         module color in rgba or hex format         |   number    | `#000000` - `#000000` | `#000000`<br />(black with 100% opacity) |
 |   `bgColor`    |       background color in rgba or hex format       |   number    | `#000000` - `#FFFFFF` | `#FFFFFF`<br />(white with 100% opacity) |
 | `borderRadius` |             border-radius (in pixels)              |   number    |    0 - `size / 2`     |                   `0`                    |
+| `cornerMode`   | how corners are rendered when borderRadius > 0     |   string    | `individual`, `merge` |              `individual`                |
+| `finderOuterShape` | shape of the outer ring of finder patterns     |   string    | `square`, `rounded`, `circle`, `drop` |          `undefined`           |
+| `finderInnerShape` | shape of the inner dot of finder patterns      |   string    | `square`, `rounded`, `circle`, `drop` |          `undefined`           |
+| `finderColor`  | color of finder patterns (overrides `color`)       |   number/string   | same as `color` |              `undefined`                |
 | `noExcavate`   |        don't remove partially covered modules      |   boolean   |    `true`, `false`    |                 `false`                  |
 
 

package/lib/browser/pdf.umd.js

@@ -761,7 +761,7 @@
     function requireCommon () {
     	if (hasRequiredCommon) return common;
     	hasRequiredCommon = 1;
-    	(function (exports) {
+    	(function (exports$1) {
 
 
     		var TYPED_OK =  (typeof Uint8Array !== 'undefined') &&
@@ -772,7 +772,7 @@
     		  return Object.prototype.hasOwnProperty.call(obj, key);
     		}
 
-    		exports.assign = function (obj /*from1, from2, from3, ...*/) {
+    		exports$1.assign = function (obj /*from1, from2, from3, ...*/) {
     		  var sources = Array.prototype.slice.call(arguments, 1);
     		  while (sources.length) {
     		    var source = sources.shift();
@@ -794,7 +794,7 @@
 
 
     		// reduce buffer size, avoiding mem copy
-    		exports.shrinkBuf = function (buf, size) {
+    		exports$1.shrinkBuf = function (buf, size) {
     		  if (buf.length === size) { return buf; }
     		  if (buf.subarray) { return buf.subarray(0, size); }
     		  buf.length = size;
@@ -851,21 +851,21 @@
 
     		// Enable/Disable typed arrays use, for testing
     		//
-    		exports.setTyped = function (on) {
+    		exports$1.setTyped = function (on) {
     		  if (on) {
-    		    exports.Buf8  = Uint8Array;
-    		    exports.Buf16 = Uint16Array;
-    		    exports.Buf32 = Int32Array;
-    		    exports.assign(exports, fnTyped);
+    		    exports$1.Buf8  = Uint8Array;
+    		    exports$1.Buf16 = Uint16Array;
+    		    exports$1.Buf32 = Int32Array;
+    		    exports$1.assign(exports$1, fnTyped);
     		  } else {
-    		    exports.Buf8  = Array;
-    		    exports.Buf16 = Array;
-    		    exports.Buf32 = Array;
-    		    exports.assign(exports, fnUntyped);
+    		    exports$1.Buf8  = Array;
+    		    exports$1.Buf16 = Array;
+    		    exports$1.Buf32 = Array;
+    		    exports$1.assign(exports$1, fnUntyped);
     		  }
     		};
 
-    		exports.setTyped(TYPED_OK); 
+    		exports$1.setTyped(TYPED_OK); 
     	} (common));
     	return common;
     }
@@ -25794,22 +25794,22 @@
     }
 
     function calculateEC(msg, ec_len) {
-        msg = [].slice.call(msg);
+        const len = msg.length;
+        const buf = new Array(len + ec_len);
+        for (let i = 0; i < len; i++)
+            buf[i] = msg[i];
+        for (let i = len; i < len + ec_len; i++)
+            buf[i] = 0;
         const poly = generatorPolynomial(ec_len);
-        for (let i = 0; i < ec_len; i++)
-            msg.push(0);
-        while (msg.length > ec_len) {
-            if (!msg[0]) {
-                msg.shift();
+        for (let offset = 0; offset < len; offset++) {
+            if (!buf[offset])
                 continue;
-            }
-            const log_k = log(msg[0]);
+            const log_k = log(buf[offset]);
             for (let i = 0; i <= ec_len; i++) {
-                msg[i] = msg[i] ^ exp(poly[i] + log_k);
+                buf[offset + i] = buf[offset + i] ^ exp(poly[i] + log_k);
             }
-            msg.shift();
         }
-        return new Uint8Array(msg);
+        return new Uint8Array(buf.slice(len));
     }
     const GF256_BASE = 285;
     const EXP_TABLE = [1];
@@ -25824,11 +25824,7 @@
         LOG_TABLE[EXP_TABLE[i]] = i;
     }
     function exp(k) {
-        while (k < 0)
-            k += 255;
-        while (k > 255)
-            k -= 255;
-        return EXP_TABLE[k];
+        return EXP_TABLE[((k % 255) + 255) % 255];
     }
     function log(k) {
         if (k < 1 || k > 255) {
@@ -26192,9 +26188,17 @@
                 bestMask = mask;
             }
         }
-        fillData(matrix, data, bestMask);
-        fillReserved(matrix, data.ec_level, bestMask);
-        return matrix.map((row) => row.map((cell) => (cell & 1)));
+        if (bestMask !== 7) {
+            fillData(matrix, data, bestMask);
+            fillReserved(matrix, data.ec_level, bestMask);
+        }
+        for (let i = 0; i < matrix.length; i++) {
+            const row = matrix[i];
+            for (let j = 0; j < row.length; j++) {
+                row[j] = (row[j] & 1);
+            }
+        }
+        return matrix;
     }
 
     const EC_LEVELS = ["L", "M", "Q", "H"];
@@ -26210,7 +26214,7 @@
         for (; i < 10; i++) {
             let version = mappedVersions[i][ec_level];
             if (version.data_len >= len) {
-                return deepCopy(version);
+                return copyTemplate(version);
             }
         }
         if (message.data10) {
@@ -26222,14 +26226,14 @@
         for (; i < 27; i++) {
             let version = mappedVersions[i][ec_level];
             if (version.data_len >= len) {
-                return deepCopy(version);
+                return copyTemplate(version);
             }
         }
         len = Math.ceil(message.data27.length / 8);
         for (; i < 41; i++) {
             let version = mappedVersions[i][ec_level];
             if (version.data_len >= len) {
-                return deepCopy(version);
+                return copyTemplate(version);
             }
         }
         throw new Error("Too much data");
@@ -26274,7 +26278,9 @@
         const data = fillTemplate(message, getTemplate(message, ec_level));
         return getMatrix(data);
     }
-    const deepCopy = typeof structuredClone !== "undefined" ? structuredClone : ((obj) => JSON.parse(JSON.stringify(obj)));
+    function copyTemplate(t) {
+        return { ...t, blocks: [...t.blocks], ec: [] };
+    }
     const versions = [
         [],
         [26, 7, 1, 10, 1, 13, 1, 17, 1],
@@ -26857,7 +26863,22 @@
         }
         return rectangles.join(" ");
     }
-    function getDotsSVGPath(matrix, size, margin = 0, borderRadius = 0) {
+    function isActive(matrix, x, y) {
+        return x >= 0 && x < matrix.length && y >= 0 && y < (matrix[0]?.length ?? 0) && !!matrix[x][y];
+    }
+    function getExposedCorners(matrix, x, y) {
+        const left = isActive(matrix, x - 1, y);
+        const right = isActive(matrix, x + 1, y);
+        const top = isActive(matrix, x, y - 1);
+        const bottom = isActive(matrix, x, y + 1);
+        return [
+            !left && !top,
+            !right && !top,
+            !right && !bottom,
+            !left && !bottom,
+        ];
+    }
+    function getDotsSVGPath(matrix, size, margin = 0, borderRadius = 0, cornerMode = 'individual') {
         let rectangles = [];
         for (let x = 0; x < matrix.length; x++) {
             const column = matrix[x];
@@ -26865,17 +26886,27 @@
                 if (column[y]) {
                     const leftX = x * size + margin;
                     const topY = y * size + margin;
-                    const delta = size - 2 * borderRadius;
+                    let rTL, rTR, rBR, rBL;
+                    if (cornerMode === 'merge') {
+                        const [eTL, eTR, eBR, eBL] = getExposedCorners(matrix, x, y);
+                        rTL = eTL ? borderRadius : 0;
+                        rTR = eTR ? borderRadius : 0;
+                        rBR = eBR ? borderRadius : 0;
+                        rBL = eBL ? borderRadius : 0;
+                    }
+                    else {
+                        rTL = rTR = rBR = rBL = borderRadius;
+                    }
                     const rectangle = [
-                        svgMove(leftX, topY + borderRadius),
-                        svgVerticalDeltaLite(delta),
-                        svgDeltaArc(borderRadius, borderRadius, borderRadius),
-                        svgHorizontalDeltaLine(delta),
-                        svgDeltaArc(borderRadius, borderRadius, -borderRadius),
-                        svgVerticalDeltaLite(-delta),
-                        svgDeltaArc(borderRadius, -borderRadius, -borderRadius),
-                        svgHorizontalDeltaLine(-delta),
-                        svgDeltaArc(borderRadius, -borderRadius, borderRadius),
+                        svgMove(leftX, topY + rTL),
+                        svgVerticalDeltaLite(size - rTL - rBL),
+                        svgDeltaArc(rBL, rBL, rBL),
+                        svgHorizontalDeltaLine(size - rBL - rBR),
+                        svgDeltaArc(rBR, rBR, -rBR),
+                        svgVerticalDeltaLite(-(size - rBR - rTR)),
+                        svgDeltaArc(rTR, -rTR, -rTR),
+                        svgHorizontalDeltaLine(-(size - rTR - rTL)),
+                        svgDeltaArc(rTL, -rTL, rTL),
                         svgReturn(),
                     ];
                     rectangles.push(...rectangle.flat());
@@ -26884,6 +26915,62 @@
         }
         return rectangles.join(" ");
     }
+    const FINDER_SIDES = [[0, 0], [1, 0], [0, 1]];
+    const FINDER_END = 7;
+    function getCornerRadii(shape, sideLength, borderRadius) {
+        const maxR = sideLength / 2;
+        switch (shape) {
+            case 'square': return [0, 0, 0, 0];
+            case 'rounded': return [borderRadius, borderRadius, borderRadius, borderRadius];
+            case 'circle': return [maxR, maxR, maxR, maxR];
+            case 'drop': return [maxR, 0, maxR, maxR];
+        }
+    }
+    function drawFinderRect(xCorner, yCorner, sideLength, xSign, ySign, sweep, cornerRadii) {
+        const [r0, r1, r2, r3] = cornerRadii;
+        return [
+            svgMove(xCorner, yCorner + r3 * ySign),
+            svgVerticalDeltaLite(ySign * (sideLength - r3 - r0)),
+            svgDeltaArc(r0, r0 * xSign, r0 * ySign, sweep),
+            svgHorizontalDeltaLine(xSign * (sideLength - r0 - r1)),
+            svgDeltaArc(r1, r1 * xSign, -r1 * ySign, sweep),
+            svgVerticalDeltaLite(-ySign * (sideLength - r1 - r2)),
+            svgDeltaArc(r2, -r2 * xSign, -r2 * ySign, sweep),
+            svgHorizontalDeltaLine(-xSign * (sideLength - r2 - r3)),
+            svgDeltaArc(r3, -r3 * xSign, r3 * ySign, sweep),
+            svgReturn(),
+        ].flat();
+    }
+    function getFinderOuterSVGPath(matrix, size, margin, borderRadius, shape) {
+        const matrixSize = matrix.length * size + margin * 2;
+        const rectangles = [];
+        for (const side of FINDER_SIDES) {
+            const [xSign, ySign] = side.map(s => s === 0 ? 1 : -1);
+            const sweep = side[1] | side[0];
+            for (const offset of [0, 1]) {
+                const sideLength = size * (FINDER_END - 2 * offset);
+                const xCorner = matrixSize * side[0] + xSign * (margin + size * offset);
+                const yCorner = matrixSize * side[1] + ySign * (margin + size * offset);
+                const radii = getCornerRadii(shape, sideLength, borderRadius);
+                rectangles.push(...drawFinderRect(xCorner, yCorner, sideLength, xSign, ySign, sweep, radii));
+            }
+        }
+        return rectangles.join(" ");
+    }
+    function getFinderInnerSVGPath(matrix, size, margin, borderRadius, shape) {
+        const matrixSize = matrix.length * size + margin * 2;
+        const rectangles = [];
+        for (const side of FINDER_SIDES) {
+            const [xSign, ySign] = side.map(s => s === 0 ? 1 : -1);
+            const sweep = side[1] | side[0];
+            const sideLength = size * (FINDER_END - 2 * 2);
+            const xCorner = matrixSize * side[0] + xSign * (margin + size * 2);
+            const yCorner = matrixSize * side[1] + ySign * (margin + size * 2);
+            const radii = getCornerRadii(shape, sideLength, borderRadius);
+            rectangles.push(...drawFinderRect(xCorner, yCorner, sideLength, xSign, ySign, sweep, radii));
+        }
+        return rectangles.join(" ");
+    }
     const commonOptions = {
         type: "png",
         parse_url: false,
@@ -26992,7 +27079,7 @@
         page.getContentStream = page.prevGetContentStream;
         page.contentStream.push = page.contentStream.prevPush;
     }
-    async function PDF({ matrix, margin, logo, logoWidth, logoHeight, color, bgColor, borderRadius, }) {
+    async function PDF({ matrix, margin, logo, logoWidth, logoHeight, color, bgColor, borderRadius, cornerMode, finderOuterShape, finderInnerShape, finderColor, }) {
         const size = 9;
         const marginPx = margin * size;
         const matrixSizePx = matrix.length * size;
@@ -27004,22 +27091,30 @@
             color: rgb(...colorToRGB(bgColor)),
         });
         page.moveTo(0, page.getHeight());
-        const path = getDotsSVGPath(matrix, size, marginPx, borderRadius);
-        page.drawSvgPath(path, {
-            color: rgb(...colorToRGB(color)),
-            opacity: getOpacity(color),
-            borderColor: rgb(...colorToRGB(color)),
-            borderOpacity: getOpacity(color),
-        });
-        const findersPath = getFindersSVGPath(matrix, size, marginPx, borderRadius);
-        patchContentStream(page);
-        page.drawSvgPath(findersPath, {
-            color: rgb(...colorToRGB(color)),
-            opacity: getOpacity(color),
-            borderColor: rgb(...colorToRGB(color)),
-            borderOpacity: getOpacity(color),
-        });
-        revertContentStream(page);
+        const fgRGB = rgb(...colorToRGB(color));
+        const fgOpacity = getOpacity(color);
+        const fgStyle = { color: fgRGB, opacity: fgOpacity, borderColor: fgRGB, borderOpacity: fgOpacity };
+        const path = getDotsSVGPath(matrix, size, marginPx, borderRadius, cornerMode);
+        page.drawSvgPath(path, fgStyle);
+        const hasFinderOptions = finderOuterShape || finderInnerShape || finderColor;
+        if (hasFinderOptions) {
+            const fc = finderColor ?? color;
+            const fcRGB = rgb(...colorToRGB(fc));
+            const fcOpacity = getOpacity(fc);
+            const fcStyle = { color: fcRGB, opacity: fcOpacity, borderColor: fcRGB, borderOpacity: fcOpacity };
+            const outerPath = getFinderOuterSVGPath(matrix, size, marginPx, borderRadius, finderOuterShape ?? 'rounded');
+            patchContentStream(page);
+            page.drawSvgPath(outerPath, fcStyle);
+            revertContentStream(page);
+            const innerPath = getFinderInnerSVGPath(matrix, size, marginPx, borderRadius, finderInnerShape ?? 'rounded');
+            page.drawSvgPath(innerPath, fcStyle);
+        }
+        else {
+            const findersPath = getFindersSVGPath(matrix, size, marginPx, borderRadius);
+            patchContentStream(page);
+            page.drawSvgPath(findersPath, fgStyle);
+            revertContentStream(page);
+        }
         if (logo) {
             let logoData;
             const header = new Uint8Array(logo.slice(0, 4));