upiqr 1.3.26 → 1.4.1

package/README.md

@@ -7,6 +7,9 @@
 
 Generate NPCI's UPI QR code (BASE64) along with UPI intent link, By using it any payment is possible from UPI enabled apps.
 
+**Zero runtime dependencies.** QR generation is implemented from scratch (no `qrcode` package or
+any other npm dependency) - smaller install size and no third-party supply-chain risk to inherit.
+
 ## Supports
 
 <div id="header" align="center">
@@ -19,16 +22,28 @@ This package will work on client and server.
 
 ```js
 
-  import upiqr from "upiqr";
+  import { upiqrSync } from "upiqr";
 
-  upiqr({
+  const { qr } = upiqrSync({
     payeeVPA: "bhar4t@upi",
     payeeName: "Bharat Sahu"
   })
-  .then(({ qr }) => {
-    console.log(qr)      // data:image/png;base64,eR0lGODP...
-  })
-  .catch(console.error)
+
+  console.log(qr)      // data:image/png;base64,eR0lGODP...
+
+```
+
+`upiqrSync` is synchronous - no `Promise`/`await` needed. The previous default export (`import
+upiqr from "upiqr"`) still works exactly as before but is **deprecated** and logs a one-time
+`console.warn`; it will be removed in a future major version:
+
+```js
+
+  import upiqr from "upiqr"; // deprecated, use upiqrSync instead
+
+  upiqr({ payeeVPA: "bhar4t@upi", payeeName: "Bharat Sahu" })
+    .then(({ qr }) => console.log(qr))
+    .catch(console.error)
 
 ```
 
@@ -54,18 +69,28 @@ For a complete list of supported fields, refer to the [NPCI UPI Linking Specs][u
 
 ### Customization:
 
-Internally using `qrcode` for QR Generation. And, it accepts [second optional param object][qr-code-options] for cusomizing the QR code.
+QR generation is implemented from scratch with **zero runtime dependencies** (a dependency-free
+QR encoder plus PNG rendering built on the platform's native APIs - Node's built-in `zlib` on the
+server, the Canvas API in the browser). It accepts a second optional options object for customizing
+the QR code:
 
 ```js
-  upiqr(intentFields, {
+  upiqrSync(intentFields, {
+    errorCorrectionLevel: 'M', // 'L' | 'M' | 'Q' | 'H' (or 'low' | 'medium' | 'quartile' | 'high'), default 'M'
+    margin: 4,                 // quiet zone width in modules, default 4
+    scale: 4,                  // pixels per module, default 4
+    width: 300,                // forces an output width in pixels; takes precedence over `scale`
     color: {
-      dark: '#000000',
-      light: '#FFFFFF'
-    }
+      dark: '#000000ff',      // dark module color (hex, RGB or RGBA), default '#000000ff'
+      light: '#ffffffff',     // light module color (hex, RGB or RGBA), default '#ffffffff'
+    },
   })
 
 ```
 
+Note: only PNG output is produced (SVG/JPEG/WebP are not supported), and byte-mode QR versions 1-10
+are supported (comfortably covering typical UPI intent URLs).
+
 <!--- [![Code Coverage][codecov-img]][codecov-url] --->
 
 [build-img]:https://github.com/bhar4t/upiqr/actions/workflows/main.yml/badge.svg
@@ -82,5 +107,4 @@ Internally using `qrcode` for QR Generation. And, it accepts [second optional pa
 [semantic-release-url]:https://github.com/semantic-release/semantic-release
 [commitizen-img]:https://img.shields.io/badge/commitizen-friendly-brightgreen.svg
 [commitizen-url]:http://commitizen.github.io/cz-cli/
-[qr-code-options]:https://www.npmjs.com/package/qrcode#qr-code-options
 [upi-specs-url]:https://www.npci.org.in/PDF/npci/upi/circular/2017/Circular18_BankCompliances_to_enbaleUPIMerchantecosystem_0.pdf

package/dist/index.browser.d.ts

@@ -0,0 +1 @@
+import{QRResult,UPIIntentParams,UpiqrRenderOptions}from'./types/upiqr.js';export declare function upiqrSync(params:UPIIntentParams,qrOptions?:UpiqrRenderOptions):QRResult;export default function upiqr(params:UPIIntentParams,qrOptions?:UpiqrRenderOptions):Promise<QRResult>;

package/dist/index.browser.js

@@ -0,0 +1 @@
+var __awaiter=this&&this.__awaiter||function(r,c,e,a){function s(n){return n instanceof e?n:new e(function(r){r(n)})}return new(e||(e=Promise))(function(n,e){function t(r){try{i(a.next(r))}catch(r){e(r)}}function o(r){try{i(a["throw"](r))}catch(r){e(r)}}function i(r){r.done?n(r.value):s(r.value).then(t,o)}i((a=a.apply(r,c||[])).next())})};import{buildUPIIntent}from"./qr/intent.js";import{encodeQRMatrix,normalizeErrorCorrectionLevel}from"./qr/encoder.js";import{renderModulesToRGBA}from"./qr/pixels.js";import{resolveRenderOptions}from"./qr/options.js";import{encodeCanvasPNG}from"./qr/canvas.js";import{warnDeprecatedAsyncDefault}from"./qr/deprecation.js";export function upiqrSync(r,n){const e=buildUPIIntent(r);try{const t=normalizeErrorCorrectionLevel(n===null||n===void 0?void 0:n.errorCorrectionLevel);const{matrix:o}=encodeQRMatrix(e,t);const i=resolveRenderOptions(o.length,n);const c=renderModulesToRGBA(o,i);const a=encodeCanvasPNG(c);return{qr:a,intent:e}}catch(r){throw new Error("Unable to generate UPI QR Code.\n"+r)}}export default function upiqr(r,n){return __awaiter(this,void 0,void 0,function*(){warnDeprecatedAsyncDefault();return upiqrSync(r,n)})}

package/dist/index.d.ts

@@ -1 +1 @@
-import QRCode from'qrcode';import{QRResult,UPIIntentParams}from'./types/upiqr';export default function upiqr({payeeVPA:pa,payeeName:pn,payeeMerchantCode:mc,transactionId:tid,transactionRef:tr,transactionNote:tn,amount:am,minimumAmount:mam,currency:cu,}:UPIIntentParams,qrOptions?:QRCode.QRCodeToDataURLOptions):Promise<QRResult>;
+import{QRResult,UPIIntentParams,UpiqrRenderOptions}from'./types/upiqr.js';export declare function upiqrSync(params:UPIIntentParams,qrOptions?:UpiqrRenderOptions):QRResult;export default function upiqr(params:UPIIntentParams,qrOptions?:UpiqrRenderOptions):Promise<QRResult>;

package/dist/index.js

@@ -1 +1 @@
-var __awaiter=this&&this.__awaiter||function(t,o,e,c){function u(n){return n instanceof e?n:new e(function(t){t(n)})}return new(e||(e=Promise))(function(n,e){function r(t){try{i(c.next(t))}catch(t){e(t)}}function a(t){try{i(c["throw"](t))}catch(t){e(t)}}function i(t){t.done?n(t.value):u(t.value).then(r,a)}i((c=c.apply(t,o||[])).next())})};import QRCode from"qrcode";function validate({pa:t,pn:n}){if(!t||!n)return"Virtual payee's address/name is compulsory";if(t.length<5||n.length<4)return"Virtual payee's address/name is too short.";return""}export default function upiqr(t,n){return __awaiter(this,arguments,void 0,function*({payeeVPA:t,payeeName:n,payeeMerchantCode:e,transactionId:r,transactionRef:a,transactionNote:i,amount:o,minimumAmount:c,currency:u},f){const s={pa:t,pn:n};if(o)s["am"]=o;if(c)s["mam"]=c;if(u)s["cu"]=u;if(e)s["mc"]=e;if(r)s["tid"]=r;if(a)s["tr"]=a;if(i)s["tn"]=i;const p=validate({pa:t,pn:n});if(p)throw new Error(p);const d="upi://pay?"+new URLSearchParams(s).toString();try{const m=yield QRCode.toDataURL(d,f);return{qr:m,intent:d}}catch(t){throw new Error("Unable to generate UPI QR Code.\n"+t)}})}
+var __awaiter=this&&this.__awaiter||function(r,c,n,a){function s(e){return e instanceof n?e:new n(function(r){r(e)})}return new(n||(n=Promise))(function(e,n){function t(r){try{i(a.next(r))}catch(r){n(r)}}function o(r){try{i(a["throw"](r))}catch(r){n(r)}}function i(r){r.done?e(r.value):s(r.value).then(t,o)}i((a=a.apply(r,c||[])).next())})};import{buildUPIIntent}from"./qr/intent.js";import{encodeQRMatrix,normalizeErrorCorrectionLevel}from"./qr/encoder.js";import{renderModulesToRGBA}from"./qr/pixels.js";import{resolveRenderOptions}from"./qr/options.js";import{encodePNG}from"./qr/png.js";import{warnDeprecatedAsyncDefault}from"./qr/deprecation.js";export function upiqrSync(r,e){const n=buildUPIIntent(r);try{const t=normalizeErrorCorrectionLevel(e===null||e===void 0?void 0:e.errorCorrectionLevel);const{matrix:o}=encodeQRMatrix(n,t);const i=resolveRenderOptions(o.length,e);const c=renderModulesToRGBA(o,i);const a=`data:image/png;base64,${encodePNG(c).toString("base64")}`;return{qr:a,intent:n}}catch(r){throw new Error("Unable to generate UPI QR Code.\n"+r)}}export default function upiqr(r,e){return __awaiter(this,void 0,void 0,function*(){warnDeprecatedAsyncDefault();return upiqrSync(r,e)})}

package/dist/qr/canvas.d.ts

@@ -0,0 +1,4 @@
+import { RGBAImage } from './pixels.js';
+import { Base64, ImageType } from '../types/upiqr.js';
+/** Renders an RGBA pixel buffer to a PNG data URL using the browser's native Canvas API. */
+export declare function encodeCanvasPNG(image: RGBAImage): Base64<ImageType>;

package/dist/qr/canvas.js

@@ -0,0 +1,11 @@
+/** Renders an RGBA pixel buffer to a PNG data URL using the browser's native Canvas API. */
+export function encodeCanvasPNG(image) {
+    const canvas = document.createElement('canvas');
+    canvas.width = image.width;
+    canvas.height = image.height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        throw new Error('Unable to acquire a 2D canvas context for QR rendering.');
+    ctx.putImageData(new ImageData(image.data, image.width, image.height), 0, 0);
+    return canvas.toDataURL('image/png');
+}

package/dist/qr/color.d.ts

@@ -0,0 +1,8 @@
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Parses a `#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa` hex color string into RGBA components. */
+export declare function parseHexColor(input: string): RGBA;

package/dist/qr/color.js

@@ -0,0 +1,21 @@
+const HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+/** Parses a `#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa` hex color string into RGBA components. */
+export function parseHexColor(input) {
+    const match = HEX_COLOR_RE.exec(input);
+    if (!match) {
+        throw new Error(`Invalid color "${input}". Expected hex format like #000000 or #000000ff.`);
+    }
+    let hex = match[1];
+    if (hex.length === 3 || hex.length === 4) {
+        hex = hex.split('').map(ch => ch + ch).join('');
+    }
+    if (hex.length === 6)
+        hex += 'ff';
+    const int = parseInt(hex, 16);
+    return {
+        r: (int >>> 24) & 0xff,
+        g: (int >>> 16) & 0xff,
+        b: (int >>> 8) & 0xff,
+        a: int & 0xff,
+    };
+}

package/dist/qr/deprecation.d.ts

@@ -0,0 +1,2 @@
+/** Emits a one-time console warning when the deprecated async default export is used. */
+export declare function warnDeprecatedAsyncDefault(): void;

package/dist/qr/deprecation.js

@@ -0,0 +1,10 @@
+let warned = false;
+/** Emits a one-time console warning when the deprecated async default export is used. */
+export function warnDeprecatedAsyncDefault() {
+    if (warned)
+        return;
+    warned = true;
+    // eslint-disable-next-line no-console
+    console.warn('[upiqr] The default export (async) is deprecated and will be removed in a future major version. ' +
+        'Use `import { upiqrSync } from "upiqr"` instead - it is synchronous and returns the result directly, no Promise required.');
+}

package/dist/qr/encoder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dependency-free QR Code encoder (byte mode, versions 1-10, ECC levels L/M/Q/H).
+ * Ported from a from-scratch reference implementation and fixed/hardened for production use.
+ *
+ * Known scope limits (by design, matching the original reference implementation):
+ * - Only byte mode (UTF-8) is supported, no numeric/alphanumeric/kanji optimization.
+ * - Only versions 1-10 are supported (max ~213 data bytes at ECC M), which comfortably
+ *   covers UPI intent URLs but will reject unusually large payloads.
+ */
+export type ECCLevel = 'L' | 'M' | 'Q' | 'H';
+export interface QRMatrixResult {
+    /** Square matrix of 0/1 values. No cell is left unresolved. */
+    matrix: number[][];
+    version: number;
+}
+declare function normalizeErrorCorrectionLevel(level?: string): ECCLevel;
+/** Encodes `text` (byte/UTF-8 mode) into the smallest fitting QR matrix (versions 1-10). */
+export declare function encodeQRMatrix(text: string, ecc: ECCLevel): QRMatrixResult;
+export { normalizeErrorCorrectionLevel };

package/dist/qr/encoder.js

@@ -0,0 +1,412 @@
+/**
+ * Dependency-free QR Code encoder (byte mode, versions 1-10, ECC levels L/M/Q/H).
+ * Ported from a from-scratch reference implementation and fixed/hardened for production use.
+ *
+ * Known scope limits (by design, matching the original reference implementation):
+ * - Only byte mode (UTF-8) is supported, no numeric/alphanumeric/kanji optimization.
+ * - Only versions 1-10 are supported (max ~213 data bytes at ECC M), which comfortably
+ *   covers UPI intent URLs but will reject unusually large payloads.
+ */
+/** Thrown internally when a payload does not fit in the given version/ECC combination. */
+class CapacityExceededError extends Error {
+}
+// Reed-Solomon block layout per version/ECC level (ISO/IEC 18004 Annex tables, versions 1-10).
+const RS_BLOCKS = {
+    1: { L: [[1, 26, 19]], M: [[1, 26, 16]], Q: [[1, 26, 13]], H: [[1, 26, 9]] },
+    2: { L: [[1, 44, 34]], M: [[1, 44, 28]], Q: [[1, 44, 22]], H: [[1, 44, 16]] },
+    3: { L: [[1, 70, 55]], M: [[1, 70, 44]], Q: [[2, 35, 17]], H: [[2, 35, 13]] },
+    4: { L: [[1, 100, 80]], M: [[2, 50, 32]], Q: [[2, 50, 24]], H: [[4, 25, 9]] },
+    5: { L: [[1, 134, 108]], M: [[2, 67, 43]], Q: [[2, 33, 15], [2, 34, 16]], H: [[2, 33, 11], [2, 34, 12]] },
+    6: { L: [[2, 86, 68]], M: [[4, 43, 27]], Q: [[4, 43, 19]], H: [[4, 43, 15]] },
+    7: { L: [[2, 98, 78]], M: [[4, 49, 31]], Q: [[2, 32, 14], [4, 33, 15]], H: [[4, 39, 13], [1, 40, 14]] },
+    8: { L: [[2, 121, 97]], M: [[2, 60, 38], [2, 61, 39]], Q: [[4, 40, 18], [2, 41, 19]], H: [[4, 40, 14], [2, 41, 15]] },
+    9: { L: [[2, 146, 116]], M: [[3, 58, 36], [2, 59, 37]], Q: [[4, 36, 16], [4, 37, 17]], H: [[4, 36, 12], [4, 37, 13]] },
+    10: { L: [[2, 86, 68], [2, 87, 69]], M: [[4, 69, 43], [1, 70, 44]], Q: [[6, 43, 19], [2, 44, 20]], H: [[6, 43, 15], [2, 44, 16]] },
+};
+// Alignment pattern center coordinates per version (versions 1-10).
+const ALIGN = {
+    1: [], 2: [6, 18], 3: [6, 22], 4: [6, 26], 5: [6, 30],
+    6: [6, 34], 7: [6, 22, 38], 8: [6, 24, 42], 9: [6, 26, 46], 10: [6, 28, 50],
+};
+// ECC indicator bits used in the 15-bit format info (ISO/IEC 18004 Table 25).
+const ECC_FORMAT = { L: 1, M: 0, Q: 3, H: 2 };
+// The 8 standard QR mask patterns (ISO/IEC 18004 Table 20).
+const MASKS = [
+    (r, c) => (r + c) % 2 === 0,
+    (r, _c) => r % 2 === 0,
+    (_r, c) => c % 3 === 0,
+    (r, c) => (r + c) % 3 === 0,
+    (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+    (r, c) => ((r * c) % 2 + (r * c) % 3) === 0,
+    (r, c) => ((r * c) % 2 + (r * c) % 3) % 2 === 0,
+    (r, c) => ((r * c) % 3 + (r + c) % 2) % 2 === 0,
+];
+function normalizeErrorCorrectionLevel(level) {
+    if (!level)
+        return 'M';
+    const map = {
+        low: 'L', medium: 'M', quartile: 'Q', high: 'H',
+        l: 'L', m: 'M', q: 'Q', h: 'H',
+    };
+    const normalized = map[level.toLowerCase()];
+    if (!normalized) {
+        throw new Error(`Invalid errorCorrectionLevel "${level}". Expected one of: L, M, Q, H, low, medium, quartile, high.`);
+    }
+    return normalized;
+}
+// GF(256) arithmetic (irreducible polynomial x^8+x^4+x^3+x^2+1 = 0x11d), as used by QR's Reed-Solomon codes.
+function gfMul(x, y) {
+    let a = x;
+    let b = y;
+    let z = 0;
+    while (b) {
+        if (b & 1)
+            z ^= a;
+        a <<= 1;
+        if (a & 0x100)
+            a ^= 0x11d;
+        b >>>= 1;
+    }
+    return z;
+}
+const EXP = new Uint8Array(512);
+const LOG = new Uint16Array(256);
+(() => {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+        EXP[i] = x;
+        LOG[x] = i;
+        x <<= 1;
+        if (x & 0x100)
+            x ^= 0x11d;
+    }
+    for (let i = 255; i < 512; i++)
+        EXP[i] = EXP[i - 255];
+})();
+function rsGenerator(degree) {
+    let g = [1];
+    for (let i = 0; i < degree; i++) {
+        const next = new Array(g.length + 1).fill(0);
+        const a = EXP[i];
+        for (let j = 0; j < g.length; j++) {
+            next[j] ^= g[j];
+            next[j + 1] ^= gfMul(g[j], a);
+        }
+        g = next;
+    }
+    return g;
+}
+const GEN_CACHE = new Map();
+function reedSolomon(data, degree) {
+    let gen = GEN_CACHE.get(degree);
+    if (!gen) {
+        gen = rsGenerator(degree);
+        GEN_CACHE.set(degree, gen);
+    }
+    const ecc = new Array(degree).fill(0);
+    for (const b of data) {
+        const f = b ^ ecc[0];
+        for (let i = 0; i < degree - 1; i++) {
+            ecc[i] = ecc[i + 1] ^ gfMul(gen[i + 1], f);
+        }
+        ecc[degree - 1] = gfMul(gen[degree], f);
+    }
+    return ecc;
+}
+function rsBlocks(version, ecc) {
+    const groups = RS_BLOCKS[version][ecc];
+    const out = [];
+    for (const [count, total, data] of groups) {
+        for (let i = 0; i < count; i++)
+            out.push({ total, data, ec: total - data });
+    }
+    return out;
+}
+function bitAppend(bits, value, len) {
+    for (let i = len - 1; i >= 0; i--)
+        bits.push((value >>> i) & 1);
+}
+function makeDataBytes(text, version, ecc) {
+    const bytes = [...new TextEncoder().encode(text)];
+    const blocks = rsBlocks(version, ecc);
+    const capacity = blocks.reduce((n, b) => n + b.data, 0);
+    const countBits = version < 10 ? 8 : 16;
+    const bits = [];
+    bitAppend(bits, 0b0100, 4); // byte mode indicator
+    bitAppend(bits, bytes.length, countBits);
+    for (const b of bytes)
+        bitAppend(bits, b, 8);
+    if (bits.length > capacity * 8) {
+        throw new CapacityExceededError(`Text is too long for version ${version} / ECC ${ecc}`);
+    }
+    for (let i = 0; i < 4 && bits.length < capacity * 8; i++)
+        bits.push(0);
+    while (bits.length % 8)
+        bits.push(0);
+    let pad = 0;
+    while (bits.length < capacity * 8) {
+        bitAppend(bits, pad++ % 2 ? 0x11 : 0xec, 8);
+    }
+    const data = [];
+    for (let i = 0; i < bits.length; i += 8) {
+        let v = 0;
+        for (let j = 0; j < 8; j++)
+            v = (v << 1) | bits[i + j];
+        data.push(v);
+    }
+    const dataBlocks = [];
+    const eccBlocks = [];
+    let pos = 0;
+    for (const block of blocks) {
+        const d = data.slice(pos, pos + block.data);
+        pos += block.data;
+        dataBlocks.push(d);
+        eccBlocks.push(reedSolomon(d, block.ec));
+    }
+    const interleaved = [];
+    const maxD = Math.max(...blocks.map(b => b.data));
+    const maxE = Math.max(...blocks.map(b => b.ec));
+    for (let i = 0; i < maxD; i++)
+        for (const d of dataBlocks)
+            if (i < d.length)
+                interleaved.push(d[i]);
+    for (let i = 0; i < maxE; i++)
+        for (const e of eccBlocks)
+            if (i < e.length)
+                interleaved.push(e[i]);
+    return interleaved;
+}
+function bitLen(x) {
+    let n = 0;
+    let v = x;
+    while (v) {
+        n++;
+        v >>>= 1;
+    }
+    return n;
+}
+function bchFormat(data) {
+    let d = data << 10;
+    const g = 0x537;
+    while (bitLen(d) - bitLen(g) >= 0)
+        d ^= g << (bitLen(d) - bitLen(g));
+    return ((data << 10) | d) ^ 0x5412;
+}
+function bchVersion(data) {
+    let d = data << 12;
+    const g = 0x1f25;
+    while (bitLen(d) - bitLen(g) >= 0)
+        d ^= g << (bitLen(d) - bitLen(g));
+    return (data << 12) | d;
+}
+function getCell(m, r, c) {
+    return m[r][c];
+}
+function setCell(m, r, c, v) {
+    m[r][c] = v;
+}
+function matrixBase(version) {
+    const n = version * 4 + 17;
+    const m = Array.from({ length: n }, () => new Array(n).fill(-1));
+    function finder(r0, c0) {
+        for (let dr = -1; dr <= 7; dr++) {
+            for (let dc = -1; dc <= 7; dc++) {
+                const r = r0 + dr;
+                const c = c0 + dc;
+                if (r < 0 || r >= n || c < 0 || c >= n)
+                    continue;
+                const dark = dr >= 0 && dr <= 6 && dc >= 0 && dc <= 6 &&
+                    (dr === 0 || dr === 6 || dc === 0 || dc === 6 || (dr >= 2 && dr <= 4 && dc >= 2 && dc <= 4));
+                setCell(m, r, c, dark ? 1 : 0);
+            }
+        }
+    }
+    finder(0, 0);
+    finder(n - 7, 0);
+    finder(0, n - 7);
+    for (let i = 8; i < n - 8; i++) {
+        if (getCell(m, 6, i) === -1)
+            setCell(m, 6, i, i % 2 === 0 ? 1 : 0);
+        if (getCell(m, i, 6) === -1)
+            setCell(m, i, 6, i % 2 === 0 ? 1 : 0);
+    }
+    if (version >= 2) {
+        const positions = ALIGN[version];
+        const first = positions[0];
+        const last = positions[positions.length - 1];
+        for (const r of positions) {
+            for (const c of positions) {
+                // Skip the 3 corner combinations that overlap a finder pattern; every other
+                // combination must be drawn unconditionally (it legitimately overrides the
+                // timing pattern where the two intersect, e.g. (6, 22) for version 7).
+                const overlapsFinder = (r === first && c === first) || (r === first && c === last) || (r === last && c === first);
+                if (overlapsFinder)
+                    continue;
+                for (let dr = -2; dr <= 2; dr++) {
+                    for (let dc = -2; dc <= 2; dc++) {
+                        const dark = Math.max(Math.abs(dr), Math.abs(dc)) !== 1;
+                        setCell(m, r + dr, c + dc, dark ? 1 : 0);
+                    }
+                }
+            }
+        }
+    }
+    // Reserve format information cells (filled in later by drawFormat).
+    for (let i = 0; i < 15; i++) {
+        const fr = i < 6 ? i : i < 8 ? i + 1 : n - 15 + i;
+        const fc = i < 8 ? n - i - 1 : i < 9 ? 15 - i : 14 - i;
+        setCell(m, fr, 8, 0);
+        setCell(m, 8, fc, 0);
+    }
+    setCell(m, n - 8, 8, 1); // fixed dark module
+    if (version >= 7) {
+        for (let i = 0; i < 18; i++) {
+            const r = Math.floor(i / 3);
+            const c = (i % 3) + n - 11;
+            setCell(m, r, c, 0);
+            setCell(m, c, r, 0);
+        }
+    }
+    return m;
+}
+function drawFormat(m, version, ecc, mask) {
+    const n = m.length;
+    const bits = bchFormat((ECC_FORMAT[ecc] << 3) | mask);
+    for (let i = 0; i < 15; i++) {
+        const bit = (bits >>> i) & 1;
+        const r = i < 6 ? i : i < 8 ? i + 1 : n - 15 + i;
+        setCell(m, r, 8, bit);
+        const c = i < 8 ? n - i - 1 : i < 9 ? 15 - i : 14 - i;
+        setCell(m, 8, c, bit);
+    }
+    setCell(m, n - 8, 8, 1);
+    if (version >= 7) {
+        const vb = bchVersion(version);
+        for (let i = 0; i < 18; i++) {
+            const bit = (vb >>> i) & 1;
+            const r = Math.floor(i / 3);
+            const c = (i % 3) + n - 11;
+            setCell(m, r, c, bit);
+            setCell(m, c, r, bit);
+        }
+    }
+}
+function makeMatrix(version, ecc, data, mask) {
+    const m = matrixBase(version);
+    const n = m.length;
+    drawFormat(m, version, ecc, mask);
+    const maskFn = MASKS[mask];
+    let bi = 0;
+    let upward = true;
+    for (let right = n - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right--;
+        for (let k = 0; k < n; k++) {
+            const r = upward ? n - 1 - k : k;
+            for (let j = 0; j < 2; j++) {
+                const c = right - j;
+                if (getCell(m, r, c) !== -1)
+                    continue;
+                let bit = 0;
+                if (bi < data.length * 8) {
+                    const b = data[bi >>> 3];
+                    bit = (b >>> (7 - (bi & 7))) & 1;
+                    bi++;
+                }
+                if (maskFn(r, c))
+                    bit ^= 1;
+                setCell(m, r, c, bit);
+            }
+        }
+        upward = !upward;
+    }
+    return m;
+}
+function penalty(m) {
+    const n = m.length;
+    let dark = 0;
+    for (const row of m)
+        for (const v of row)
+            dark += v;
+    let p = 0;
+    for (let r = 0; r < n; r++) {
+        let run = 1;
+        for (let c = 1; c < n; c++) {
+            if (getCell(m, r, c) === getCell(m, r, c - 1))
+                run++;
+            else {
+                if (run >= 5)
+                    p += 3 + run - 5;
+                run = 1;
+            }
+        }
+        if (run >= 5)
+            p += 3 + run - 5;
+    }
+    for (let c = 0; c < n; c++) {
+        let run = 1;
+        for (let r = 1; r < n; r++) {
+            if (getCell(m, r, c) === getCell(m, r - 1, c))
+                run++;
+            else {
+                if (run >= 5)
+                    p += 3 + run - 5;
+                run = 1;
+            }
+        }
+        if (run >= 5)
+            p += 3 + run - 5;
+    }
+    for (let r = 0; r < n - 1; r++) {
+        for (let c = 0; c < n - 1; c++) {
+            const x = getCell(m, r, c);
+            if (x === getCell(m, r, c + 1) && x === getCell(m, r + 1, c) && x === getCell(m, r + 1, c + 1))
+                p += 3;
+        }
+    }
+    const pattern = [1, 0, 1, 1, 1, 0, 1];
+    function matchLine(arr) {
+        for (let i = 0; i <= arr.length - 7; i++) {
+            let ok = true;
+            for (let j = 0; j < 7; j++) {
+                if (arr[i + j] !== pattern[j]) {
+                    ok = false;
+                    break;
+                }
+            }
+            if (ok)
+                p += 40;
+        }
+    }
+    for (let r = 0; r < n; r++)
+        matchLine([...m[r]]);
+    for (let c = 0; c < n; c++)
+        matchLine(Array.from({ length: n }, (_, r) => getCell(m, r, c)));
+    p += Math.floor(Math.abs((100 * dark) / (n * n) - 50) / 5) * 10;
+    return p;
+}
+function chooseMask(version, ecc, data) {
+    let best = null;
+    for (let mask = 0; mask < 8; mask++) {
+        const m = makeMatrix(version, ecc, data, mask);
+        const score = penalty(m);
+        if (!best || score < best.score)
+            best = { m, score };
+    }
+    return best.m;
+}
+/** Encodes `text` (byte/UTF-8 mode) into the smallest fitting QR matrix (versions 1-10). */
+export function encodeQRMatrix(text, ecc) {
+    for (let version = 1; version <= 10; version++) {
+        try {
+            const data = makeDataBytes(text, version, ecc);
+            return { matrix: chooseMask(version, ecc, data), version };
+        }
+        catch (e) {
+            if (!(e instanceof CapacityExceededError))
+                throw e;
+        }
+    }
+    throw new Error('Input is too long to encode. This implementation supports QR versions 1-10 (byte mode); reduce the payload length or lower the error correction level.');
+}
+export { normalizeErrorCorrectionLevel };

package/dist/qr/intent.d.ts

@@ -0,0 +1,3 @@
+import { UPIIntentParams } from '../types/upiqr.js';
+/** Validates UPI intent params and builds the `upi://pay?...` deep link. */
+export declare function buildUPIIntent({ payeeVPA: pa, payeeName: pn, payeeMerchantCode: mc, transactionId: tid, transactionRef: tr, transactionNote: tn, amount: am, minimumAmount: mam, currency: cu, }: UPIIntentParams): string;

package/dist/qr/intent.js

@@ -0,0 +1,29 @@
+function validate({ pa, pn }) {
+    if (!pa || !pn)
+        return "Virtual payee's address/name is compulsory";
+    if (pa.length < 5 || pn.length < 4)
+        return "Virtual payee's address/name is too short.";
+    return '';
+}
+/** Validates UPI intent params and builds the `upi://pay?...` deep link. */
+export function buildUPIIntent({ payeeVPA: pa, payeeName: pn, payeeMerchantCode: mc, transactionId: tid, transactionRef: tr, transactionNote: tn, amount: am, minimumAmount: mam, currency: cu, }) {
+    const error = validate({ pa, pn });
+    if (error)
+        throw new Error(error);
+    const params = { pa, pn };
+    if (am)
+        params['am'] = am;
+    if (mam)
+        params['mam'] = mam;
+    if (cu)
+        params['cu'] = cu;
+    if (mc)
+        params['mc'] = mc;
+    if (tid)
+        params['tid'] = tid;
+    if (tr)
+        params['tr'] = tr;
+    if (tn)
+        params['tn'] = tn;
+    return 'upi://pay?' + new URLSearchParams(params).toString();
+}

package/dist/qr/options.d.ts

@@ -0,0 +1,4 @@
+import { UpiqrRenderOptions } from '../types/upiqr.js';
+import { RenderOptions } from './pixels.js';
+/** Resolves user-supplied renderer options against defaults matching the previous `qrcode` package behavior. */
+export declare function resolveRenderOptions(moduleCount: number, options?: UpiqrRenderOptions): RenderOptions;

package/dist/qr/options.js

@@ -0,0 +1,21 @@
+import { parseHexColor } from './color.js';
+/** Resolves user-supplied renderer options against defaults matching the previous `qrcode` package behavior. */
+export function resolveRenderOptions(moduleCount, options) {
+    var _a, _b;
+    var _c, _d, _e, _f;
+    const margin = (_c = options === null || options === void 0 ? void 0 : options.margin) !== null && _c !== void 0 ? _c : 4;
+    if (margin < 0)
+        throw new Error('margin must be a non-negative number.');
+    const dark = parseHexColor((_d = (_a = options === null || options === void 0 ? void 0 : options.color) === null || _a === void 0 ? void 0 : _a.dark) !== null && _d !== void 0 ? _d : '#000000ff');
+    const light = parseHexColor((_e = (_b = options === null || options === void 0 ? void 0 : options.color) === null || _b === void 0 ? void 0 : _b.light) !== null && _e !== void 0 ? _e : '#ffffffff');
+    let scale = (_f = options === null || options === void 0 ? void 0 : options.scale) !== null && _f !== void 0 ? _f : 4;
+    if (scale <= 0)
+        throw new Error('scale must be a positive number.');
+    if (options === null || options === void 0 ? void 0 : options.width) {
+        const totalModules = moduleCount + margin * 2;
+        const computed = Math.floor(options.width / totalModules);
+        if (computed > 0)
+            scale = computed;
+    }
+    return { scale, margin, dark, light };
+}

package/dist/qr/pixels.d.ts

@@ -0,0 +1,15 @@
+import { RGBA } from './color.js';
+export interface RenderOptions {
+    scale: number;
+    margin: number;
+    dark: RGBA;
+    light: RGBA;
+}
+export interface RGBAImage {
+    width: number;
+    height: number;
+    /** Row-major RGBA pixel data, 4 bytes per pixel. */
+    data: Uint8ClampedArray<ArrayBuffer>;
+}
+/** Rasterizes a QR module matrix into an RGBA pixel buffer, applying scale/margin/colors. */
+export declare function renderModulesToRGBA(matrix: readonly (readonly number[])[], options: RenderOptions): RGBAImage;

package/dist/qr/pixels.js

@@ -0,0 +1,22 @@
+/** Rasterizes a QR module matrix into an RGBA pixel buffer, applying scale/margin/colors. */
+export function renderModulesToRGBA(matrix, options) {
+    const { scale, margin, dark, light } = options;
+    const n = matrix.length;
+    const size = (n + margin * 2) * scale;
+    const data = new Uint8ClampedArray(size * size * 4);
+    for (let y = 0; y < size; y++) {
+        const moduleRow = Math.floor(y / scale) - margin;
+        const row = moduleRow >= 0 && moduleRow < n ? matrix[moduleRow] : undefined;
+        for (let x = 0; x < size; x++) {
+            const moduleCol = Math.floor(x / scale) - margin;
+            const isDark = row !== undefined && moduleCol >= 0 && moduleCol < n && row[moduleCol] === 1;
+            const color = isDark ? dark : light;
+            const idx = (y * size + x) * 4;
+            data[idx] = color.r;
+            data[idx + 1] = color.g;
+            data[idx + 2] = color.b;
+            data[idx + 3] = color.a;
+        }
+    }
+    return { width: size, height: size, data };
+}

package/dist/qr/png.d.ts

@@ -0,0 +1,3 @@
+import { RGBAImage } from './pixels.js';
+/** Encodes an RGBA pixel buffer as a PNG (truecolor + alpha), using only Node's built-in zlib. */
+export declare function encodePNG(image: RGBAImage): Buffer;

package/dist/qr/png.js

@@ -0,0 +1,54 @@
+import { deflateSync } from 'node:zlib';
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+function buildCrcTable() {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+}
+const CRC_TABLE = buildCrcTable();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (const byte of buf)
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const typeAndData = Buffer.concat([Buffer.from(type, 'ascii'), data]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(typeAndData), 0);
+    return Buffer.concat([length, typeAndData, crc]);
+}
+/** Encodes an RGBA pixel buffer as a PNG (truecolor + alpha), using only Node's built-in zlib. */
+export function encodePNG(image) {
+    const { width, height, data } = image;
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr.writeUInt8(8, 8); // bit depth
+    ihdr.writeUInt8(6, 9); // color type: truecolor + alpha
+    ihdr.writeUInt8(0, 10); // compression method
+    ihdr.writeUInt8(0, 11); // filter method
+    ihdr.writeUInt8(0, 12); // interlace method
+    const stride = width * 4;
+    const rgba = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    const raw = Buffer.alloc((stride + 1) * height);
+    for (let y = 0; y < height; y++) {
+        const destStart = y * (stride + 1);
+        raw[destStart] = 0; // filter type: none
+        rgba.copy(raw, destStart + 1, y * stride, y * stride + stride);
+    }
+    const idat = deflateSync(raw, { level: 9 });
+    return Buffer.concat([
+        PNG_SIGNATURE,
+        chunk('IHDR', ihdr),
+        chunk('IDAT', idat),
+        chunk('IEND', Buffer.alloc(0)),
+    ]);
+}

package/dist/types/upiqr.d.ts

@@ -1,3 +1,5 @@
 
-export type ImageType='png'|'jpeg'|'webp';export type Base64<imageType extends ImageType>=`data:image/${imageType};base64,${string}`;export interface UPIIntentParams{payeeVPA:string;payeeName:string;payeeMerchantCode?:string;transactionId?:string;transactionRef?:string;transactionNote?:string;amount?:string;minimumAmount?:string;currency?:string;transactionRefUrl?:string;}
+export type ImageType='png';export type Base64<imageType extends ImageType>=`data:image/${imageType};base64,${string}`;export type ErrorCorrectionLevel='low'|'medium'|'quartile'|'high'|'L'|'M'|'Q'|'H';export interface UpiqrColorOptions{dark?:string;light?:string;}
+export interface UpiqrRenderOptions{errorCorrectionLevel?:ErrorCorrectionLevel;margin?:number;scale?:number;width?:number;color?:UpiqrColorOptions;}
+export interface UPIIntentParams{payeeVPA:string;payeeName:string;payeeMerchantCode?:string;transactionId?:string;transactionRef?:string;transactionNote?:string;amount?:string;minimumAmount?:string;currency?:string;transactionRefUrl?:string;}
 export interface QRResult{qr:Base64<ImageType>;intent:string;}

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "upiqr",
-  "version": "1.3.26",
-  "description": "Generate NPCI's UPI QR code along with UPI intent link, By using it any payment is possible from UPI enabled apps.",
+  "version": "1.4.1",
+  "description": "Zero-dependency UPI QR code (PNG) and intent link generator for NPCI-compliant payments - works in Node.js and the browser, written in TypeScript.",
+  "homepage": "https://github.com/bhar4t/upiqr#readme",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "browser": {
+    "./dist/index.js": "./dist/index.browser.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/index.browser.js",
+      "node": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "type": "module",
   "files": [
     "dist",
@@ -13,8 +25,9 @@
   ],
   "scripts": {
     "clean": "rimraf dist",
-    "minify": "jsmin -o dist/types/upiqr.d.ts dist/types/upiqr.d.ts && jsmin -o dist/index.d.ts dist/index.d.ts && uglifyjs -o dist/index.js dist/index.js --mangle",
-    "build": "npm run clean && tsc && npm run minify"
+    "minify": "jsmin -o dist/types/upiqr.d.ts dist/types/upiqr.d.ts && jsmin -o dist/index.d.ts dist/index.d.ts && jsmin -o dist/index.browser.d.ts dist/index.browser.d.ts && uglifyjs -o dist/index.js dist/index.js --mangle && uglifyjs -o dist/index.browser.js dist/index.browser.js --mangle",
+    "build": "npm run clean && tsc && npm run minify",
+    "test": "tsx --test src/__tests__/encoder.test.ts src/__tests__/roundtrip.test.ts src/__tests__/index.test.ts src/__tests__/canvas.test.ts"
   },
   "repository": {
     "type": "git",
@@ -24,12 +37,25 @@
     "upi",
     "upiqr",
     "qrcode",
+    "qr code",
+    "qr code generator",
+    "qr code npm",
+    "zero dependency",
+    "zero dependencies",
+    "dependency-free",
+    "typescript",
     "payment",
     "accept payment",
+    "upi payment",
     "upi qr code generator",
-    "qr code generator",
     "upi qr code",
-    "NPCI"
+    "upi qr generator",
+    "upi id",
+    "vpa",
+    "bharat qr",
+    "india payments",
+    "npci",
+    "npci upi"
   ],
   "publishConfig": {
     "provenance": true
@@ -40,14 +66,12 @@
     "type": "github",
     "url": "https://github.com/sponsors/bhar4t/"
   },
-  "dependencies": {
-    "qrcode": "^1.4.4"
-  },
   "devDependencies": {
     "@types/node": "^26.6.2",
-    "@types/qrcode": "^1.5.1",
     "jsmin": "^1.0.1",
+    "jsqr": "^1.4.0",
     "rimraf": "^6.1.3",
+    "tsx": "^4.23.15",
     "typescript": "^7.0.2",
     "uglify-js": "^3.19.3"
   }