qreator 9.7.1 → 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;
     }
@@ -10808,7 +10808,6 @@
         var flags = makeFontFlags({
             fixedPitch: font.post.isFixedPitch,
             serif: 1 <= familyClass && familyClass <= 7,
-            symbolic: true,
             script: familyClass === 10,
             italic: font.head.macStyle.italic,
         });
@@ -11598,7 +11597,7 @@
     h=A(N,d+5,5)+1;Q=A(N,d+10,4)+4;d+=14;var j=1;for(var c=0;c<38;c+=2){b.Q[c]=0;b.Q[c+1]=0;}for(var c=0;
     c<Q;c++){var K=A(N,d+c*3,3);b.Q[(b.X[c]<<1)+1]=K;if(K>j)j=K;}d+=3*Q;M(b.Q,j);I(b.Q,j,b.u);v=b.w;C=b.d;
     d=l(b.u,(1<<j)-1,J+h,N,d,b.v);var r=V.V(b.v,0,J,b.C);X=(1<<r)-1;var S=V.V(b.v,J,h,b.D);u=(1<<S)-1;M(b.C,r);
-    I(b.C,r,v);M(b.D,S);I(b.D,S,C);}while(!0){var T=v[e(N,d)&X];d+=T&15;var p=T>>>4;if(p>>>8==0){W[w++]=p;}else if(p==256){break}else {var z=w+p-254;
+    I(b.C,r,v);M(b.D,S);I(b.D,S,C);}while(true){var T=v[e(N,d)&X];d+=T&15;var p=T>>>4;if(p>>>8==0){W[w++]=p;}else if(p==256){break}else {var z=w+p-254;
     if(p>264){var _=b.q[p-257];z=w+(_>>>3)+A(N,d,_&7);d+=_&7;}var $=C[e(N,d)&u];d+=$&15;var s=$>>>4,Y=b.c[s],a=(Y>>>4)+n(N,d,Y&15);
     d+=Y&15;while(w<z){W[w]=W[w++-a];W[w]=W[w++-a];W[w]=W[w++-a];W[w]=W[w++-a];}w=z;}}}return W.length==w?W:W.slice(0,w)};
     H.H.W=function(N,W){var R=N.length;if(W<=R)return N;var V=new Uint8Array(R<<1);V.set(N,0);return V};
@@ -17551,7 +17550,7 @@
         var p3x = 1 - 0.31;
         // (x, y) coords of the check mark's center (vertically) point
         var p1x = -1 + 0.325;
-        var p1y = -((p1x - p2x) * (p3x - p2x)) / (p3y - p2y) + p2y;
+        var p1y = 0.3995 / (p3y - p2y) + p2y;
         /****************************************************************************/
         return [
             pushGraphicsState(),
@@ -22473,57 +22472,7 @@
     };
 
     var PageSizes = {
-        '4A0': [4767.87, 6740.79],
-        '2A0': [3370.39, 4767.87],
-        A0: [2383.94, 3370.39],
-        A1: [1683.78, 2383.94],
-        A2: [1190.55, 1683.78],
-        A3: [841.89, 1190.55],
-        A4: [595.28, 841.89],
-        A5: [419.53, 595.28],
-        A6: [297.64, 419.53],
-        A7: [209.76, 297.64],
-        A8: [147.4, 209.76],
-        A9: [104.88, 147.4],
-        A10: [73.7, 104.88],
-        B0: [2834.65, 4008.19],
-        B1: [2004.09, 2834.65],
-        B2: [1417.32, 2004.09],
-        B3: [1000.63, 1417.32],
-        B4: [708.66, 1000.63],
-        B5: [498.9, 708.66],
-        B6: [354.33, 498.9],
-        B7: [249.45, 354.33],
-        B8: [175.75, 249.45],
-        B9: [124.72, 175.75],
-        B10: [87.87, 124.72],
-        C0: [2599.37, 3676.54],
-        C1: [1836.85, 2599.37],
-        C2: [1298.27, 1836.85],
-        C3: [918.43, 1298.27],
-        C4: [649.13, 918.43],
-        C5: [459.21, 649.13],
-        C6: [323.15, 459.21],
-        C7: [229.61, 323.15],
-        C8: [161.57, 229.61],
-        C9: [113.39, 161.57],
-        C10: [79.37, 113.39],
-        RA0: [2437.8, 3458.27],
-        RA1: [1729.13, 2437.8],
-        RA2: [1218.9, 1729.13],
-        RA3: [864.57, 1218.9],
-        RA4: [609.45, 864.57],
-        SRA0: [2551.18, 3628.35],
-        SRA1: [1814.17, 2551.18],
-        SRA2: [1275.59, 1814.17],
-        SRA3: [907.09, 1275.59],
-        SRA4: [637.8, 907.09],
-        Executive: [521.86, 756.0],
-        Folio: [612.0, 936.0],
-        Legal: [612.0, 1008.0],
-        Letter: [612.0, 792.0],
-        Tabloid: [792.0, 1224.0],
-    };
+        A4: [595.28, 841.89]};
 
     var ParseSpeeds;
     (function (ParseSpeeds) {
@@ -25845,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];
@@ -25875,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) {
@@ -26243,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"];
@@ -26261,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) {
@@ -26273,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");
@@ -26325,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],
@@ -26908,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];
@@ -26916,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());
@@ -26935,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,
@@ -27043,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;
@@ -27055,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));