pi-spi-sdk 0.1.3 → 0.2.0

package/dist/qrcode/index.mjs

@@ -0,0 +1,712 @@
+// src/qrcode/logo.ts
+var AMBER_LOGO_SEGMENTS = [
+  "iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAMAAABlApw1AAACUlBMVEUAAAD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7",
+  "uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQD7uQBqFsbfAAAAxXRSTlMAAAUpaqDF2uPq7ezn",
+  "4djPzsvDwsC3trCdfVEdAgtJn977/vXUlUQIQK7087FHHJ7vKBmsLBqtyi8bMC3WuSs+v9EjvLM0ILW9",
+  "zR4yxh8Xphb9shil+Ov8bzND4BUh14g3pKgmmQdL+YsO7j8PupYKVSVKaKI15cETLnpkca+n08QN5gOX",
+  "XV5gTV9TbooU0HTdQYmOewaMIk8E6PZc0tyakN9CTPJaZcgBRngJJDs4gEhY8E5SEpwREGHi5JuU2/dw",
+  "ofG+YwjdAcYAAAZRSURBVHja7Z37XxRVGIfnhULYFQQlNJTLriGiSSiBGGFihVwqm0BJMfOGS2aE5C2z",
+  "q0ghGqXdyBQrIaKbUWSl2fX8X82wrCyX2Xln59zm8znfn4fZ59nznrOzh3POalqcgYTEO+5MmpNsJsXn",
+  "nxbf3OTJpM6ZSNq89PFkzF9gJvOuLCMLF92dvXgJxMsRL35Obl5+gNBJcOk9BctygKMDFC4vWkGJfiIr",
+  "713FTwGK7yuhiz+uULSakwGsKaWPb2bB/VwMoKycDT8hays4GDDk52LAlJ+9AcA6pvyGwQNMDaAyM8hW",
+  "gDy4jKEBlFUxxjcybz0zA8b1H8n8REYGnPiZGXDjZ2TAkZ+FAUBlFevxJzoZD1E2gOINHPGNVNMdi7jW",
+  "TzhUq0gAv2FA7+laCD8hGzZSMhDET8jDVAwAEh/hOf5EJ/NRCgZQkyQI30i1+54srH7CcV1FgvldGwjn",
+  "d2fA/vsXWwNj/Nkkmt5MbZxPFQZ/nWj2cNLjGosA6rNEk0eSVe/cwOCXon7C2eTYQC5+5way8Ts1ANgo",
+  "Gb9h4GA0BajIEM07MxnoWUejfjjMXzlPVT1OQL76j2RhGcZAXn5CyhEGMvNjDABqJOY3DNbF7skADY+J",
+  "ZoyZYGYlxOR/nPP8lfNUxagiues/Eut+4A1+awOv8BsGT4Cn+Ulw85MwC3+D9P33dvSnZsybgtD5K+ep",
+  "agSv1k84waYpVeQ5/mkGTviDW0q28omvGW2A5/cXPb1qWwWXVG5vsWuDHRMG8AySf+ezuwq5rQuDNWk2",
+  "OPrucE+GnD0o/EDTXq7L2mwFCNnXCmYH2L8Swx9qe47rykKMwIHnTYGDL6AaoD2H78pIjAApfxE06NiC",
+  "4U87xHllJ0pgRSdohagVfIGXeNY/WoAcTtCOHMUIHDvOfWktSiD1Ze2EjrhOf4V3AyAFmk9qr2Ia4Ggi",
+  "b36kAHlNex1z2RtvyiqQrr2F8jwlq0Cy5sNc1sW9C2AF/Jofc1k7d34loASUgBJQAkpACSgBeQRqT3ff",
+  "ztvbLGyg9Z2ebkR61lvdIOfM5A1O986lKECCkyFnrV7/3LvR11mG9FndoL5lygvRFIhOWwwBVKwFUh3D",
+  "KAEloASUgBJQAkpACSgBJaAElIASUAJKQAkoASWgBJSAElACSkAJKAFXAsXveVygtcnbAhoklqPWcUsr",
+  "oEHO+33n28K5gKonIQIfoLYFf4ja1SBE4CPMGkiZBXZjzjiWWeAYZiuCzAItH3tcIPSJxwWMOyA298ss",
+  "sBaxnUJqgaW5Hhcgef22BnILfLrL4wKk1PajAC2A2gBBXeDiZ3YDEVogRYgAuWS3sQ4tcFmMABlIABoC",
+  "yVqmIIGSDptTUnACddoVQQLk8y9iGiAFNmtfXhUkQFoGY23uwgmEhrQdX4kSIL7eVnApkL9agxPCBMjF",
+  "K42WZYQTyOvXYK/TcYieAAnWNgyDC4GrX4MGMILZz8pGwOgIIxZnNqEE9nxj7klffEmgANGr+76drTNj",
+  "BPzfmX8IsN/ZlKSlwPF4BAyF/KaT35/rn9YQCIHQD+EPQ4Bs1K7uSEqvdc6a3B/z4xIwEhytLj3fO5gd",
+  "fbef7E4b1AsiT4QAPzsxaA5ZxeX51Hpgyt1suqa+aGzybBJnBlIkmt+LBlP5TYMzzp+rJeI3DJYMoTbd",
+  "yBH98Mx5DS9V0cz331sGs/N7x8CK3ysG1vzjBtL35OYY/KbB0FbRhDb8v1yP/VV6WO4qChT8ajcdI3U/",
+  "CBQctJ+TlNgAwy+zAY5fXgMsv2nw2wHRtDOjD+DPiYNTHdK1QaD9OppfxirC14+cBk75ZTNwzi+XQTz8",
+  "psHgqGjycPSu+M6phIRBKdog0DUWF78sVRRf/chj4IZfBgN3/OIN3PKbBh0Cn4v0Avfn5EJ/z+/C3v8B",
+  "J88/1m3Q6XxJMx1+1/Uj1oAWvygDevxiDGjyj/8fjfOMF11+c76o+wZX/pt28z9yVxHt95+3AQt+ngZs",
+  "+PkZsOIfN0j2Mr9p0M18NG2+yY7fHE0drquI4/2nPX5ObwO2/YBl/fAwYM/P1iDwB3t+0+DaLTb8f57l",
+  "c8g+wPb0AAP+lBFev3ID0PjXTtq/XT/695EETvymwnBNX9I/9OhDl/ctb+WHH26FsdwL/95K8fld50Zd",
+  "03+H7Ld0WOR/rIwlUtPE/X8AAAAASUVORK5CYII="
+];
+var OCTO_QRCODE_LOGO_SEGMENTS = [
+  "iVBORw0KGgoAAAANSUhEUgAAAPYAAAD6CAYAAACS0LqzAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAA",
+  "AAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAA9qADAAQAAAABAAAA+gAA",
+  "AAA4bIViAAAVTklEQVR4Ae2dW2xcx3nHZ5bcpVYXmEEkBPYDuXmI5ASoJVVGEyCwRD4YsFE5lquXpK0Q",
+  "CYUvDwYiG0iARkEkAbGLGkVsoyrgSwNLdYq4LRQ7qQEH9YNoGQGSoJIYP0ixXrr0g51ADkJDIpdcUns6",
+  "H9cUd8nl7jln5/LNzH8AWrvnMueb3zc/z+w5Z89KgZKaQFKrVRbEzTE5UNjZaIiKFGLXqp0rq94zeptM",
+  "CyHVn/ZS1VVjIsS0lCsxSplM31xsTA3IgcliuTyh6zgx1KP6Jko3AkmSDM/XZg4XCoUH1XZj3bbFOuME",
+  "JkTSOFPcsOmN1v8BGD+qhweA2OskjYRerM99K0kaR9VIN7zOZljshkBVyGSi2CiclOVy1U0IvI8KsTvk",
+  "Z3F+5kAjEa9A6A5weC2qNoR4fsOGjc/xCst9NBC7JQc0Si/UZ58ViTzcshgv+ROYKCbyCEbvlURB7E9Z",
+  "1NSJsYFC8rpI1pwQW6GFV5wJVEVh8KFSqTTJOUhbsUFsRXpJapmcUy8rtsDjOAYISDEt5OA45FYfIg3g",
+  "9apKSO1VunoHC7mXGEUtNqTu7YmXW0DueEdsSO2lsumDjlzuKEdsSJ3eD6+3jFju6MSG1F6rmif4qroU",
+  "Nh7bpbCoxF66Tj1fu6R6RyVPD8E+3hKITu6Ct6nKGHjz5pMaLmll5BbI5pUFdTmTvsQTSHt6NiOKEfuW",
+  "1Lj5pGeHCHyDaEbu4MWG1IGrmr15UcgdtNiQOnuvj2SP4OUOVmxIHYmi+ZsZtNxBig2p8/f2yPYMVu7g",
+  "xIbUkanZf3ODlDs4sevzs5fw1cv+e3tkNQQnd1DXsevzM69A6siU1NPc4K5zBzNiN6XGk0/09PNoawlm",
+  "5A5CbEgdrYgmGl4tDpV3+/4UVO+n4pDaRN+Ous7KQr12jk7C+kzB6xEbUvvc9ZjHLsVksVQe93Xk9lZs",
+  "blLPXJ8WVy68u/R37fdTYurqe0s9d/b6J4LWcSnb7hjVHsq227PXue32ETGyfaeobL9LfHHPPdpj0lKh",
+  "x3J7KTYnqa9cOC/eeu1floTmJLCWjm2pkk1bhsWefQ+Ig498V+T5n4TRMD2V2zuxF+Zmn02EOGo0mSkq",
+  "v/bRlHjx5KPishIbRR+BvfsP8RPcQ7m9EnthvnZcndQ4oa8b5avprddOiZ++9DSrKXa+lvDd6+Ajx8TB",
+  "h4/xCdAzub0Rm4vUZ19+Spx96Sk+HS7gSO4ee0A8+v0XBU3VWRSZnC4NbTrCIpYeQXghNqTukcWAV4+q",
+  "k2vfe+EXkDtjjtmLDakzZjTAzSF39qSyFhtSZ09oqHtA7myZZSs2pM6WyBi2htzps8xSbEidPoGxbQm5",
+  "02Wc3b3ikDpd4mLdiu7o+8Fj9/G51Kh+S72u7q3glg9WYkNqbt2DZzzs5FY3TFHf5USLzVQcUnPqFn7E",
+  "wm1arr4wckJ95fMkB3osxIbUHLqCnzFA7s55cy42pO6cGCxNTwByr2XlVGxIvTYhWJKPAORu5+ZMbEjd",
+  "ngi8658A5F5h6ERsSL2SALzSSwByN3laF7s+N/ctIRrP6U1n9trwLa3szHzZA3ILYVXsxXr9m43G4mnX",
+  "HQRSu86A+ePHLrc1sSG1+c6MI7QTiFluK2JD6vYOh3f2CMQqt3GxIbW9TowjdSZAcv/Dv/+q80oHS23c",
+  "oWb0XnEuUr/6w+/gcUYOOjCXQ9K95fTgSS6FnttHbpiMx9iIzUXqF1RCz7/5qkmGqNsTAvvUE1AfPf4i",
+  "m2gLhcHDg6XSGRMBGREbUptIFerUQSAWubWLvVCrjSUyOacjCf3UgZG6H3ph7xuD3Fo/Y9dv3NiVyMbr",
+  "rrsFpHadAd7Hf0d9NOP0mZvu7dD9mVvbiE1Si0GpRmrp9CHQkJq3VJyiC3nk1iI2pObUXRFLFgLc5JaJ",
+  "HC+WyxNZ2tBp276n4pC6E1Ys84UAt2l5Ukher9fru/rl19eIDan7xY/9uRBgNXJLMS3k4HipVJrMyye3",
+  "2JA6L3Lsx5VASHLnEhtSc+2aiKtfAqHInVnsWq1WGZCNSzj73W8Xwv5cCYQgd6aTZ02p6eYTXNLi2ikR",
+  "V/8EWJ1QS8SwSBbPZT2hlnrEXpFaVPpHl78GXKfOzw57ZiPAauQWolpUl8JkuVxN04pUYkPqNCixTYgE",
+  "fJW7p9iQOsTuijZlIeCj3F3FhtRZ0o9tQybgm9zrig2pQ+6maFseAj7J3VFsSJ0n7dgnBgK+yL1GbEgd",
+  "Q/dEG/shwE7uofJu9Ry16dY2rbmOXZCNZ9UGldaNbL/GJS3bxHG8LARYXedWri7UZ8nZttImNv1KhxTy",
+  "QNsWlt9AasvAcbhcBFjJncjDi/Mzbd7emopzmIJD6lx9DDs5JMBmWq6+EVYslT+/PCW/NWIPFBrHFZ+K",
+  "K0aQ2hV5HLcfAmxGbnXraX1u9uhyW5ZG7E9H6/9bXmj7X0htmziOp5sAi5G7ZdReGrEHxM0x3Q1NWx+k",
+  "TksK23EmwGLkVqP2/HztMHFqTsVlgabh1gukto4cBzRIgIPcSugHqYnS1TQcUhvsYajaKQHX0/LiUPkz",
+  "BRfTcEjttN/h4IYJuB65F+ZmDhREQe4z3M626iF1Gw68CZSAU7ml2DUokkJFiMQKXl+k3rhBiK/uFGLk",
+  "c0LcOSJEWb2nZSj+EPjle0L86Odu4yW5qdj+IcBGQ1YGldSVpaMb/s/Zl59i/6uXW4fVmYe9QuzeDpEN",
+  "d4doqie5t94xIg4+fMxamwsFuVOJbf6mFJL67EtPWWtYngPd+2Ul9T0QOg877NOdAPX9jVtuE/d//fHu",
+  "G+pbW7l155m+OttruvbRFHupaZT+xr2Quj1zeKeTAMlNLtgqxsXm9KuGnaCS1PSHAgImCcxe/8TqL3wa",
+  "FfvKhfPisvrjWugEGaTmmp3w4iIXLl9410rDjIp99uWnrTQiz0GWTpSpz9QoIGCTwFuvnbJyOGNi0+cJ",
+  "zqM1jdQkNwoI2CRAs9iZ69PGD2lM7CuWphx5CNE1abqkhQICtgnQZ+0LE28aP6wxsf934r+NB5/3ALt3",
+  "4Ax4XnbYr38CU1fV3TOGizGxP/7oA8Oh56/+ztH8+2JPEOiXwOWL5k+gGRPb5jW7rKC33pZ1D2wPAvoI",
+  "zPr8GdvGCYK8qCF2XnLYTwcBG4OesRFbBwDUAQIgkI8AxM7HDXuBAGsCEJt1ehAcCOQjALHzccNeIMCa",
+  "AMRmnR4EBwL5CEDsfNywFwiwJgCxWacHwYFAPgIQOx837AUCrAlAbNbpQXAgkI8AxM7HDXuBAGsCEJt1",
+  "ehAcCOQjALHzccNeIMCaAMRmnR4EBwL5CNBzxaMrF69mf9DCZ9VXPW19j/vS+0LMzvNOy44Re4+Wol/1",
+  "yFp+Z+9Jv1lDs7J9lGL/5H+ys/3qXfbEfvs3QnDvmH/3NXtiu/6pnuy9xf0emIq7zwEiAAHtBCC2dqSo",
+  "EATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBP",
+  "AGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+",
+  "B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ",
+  "0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGI",
+  "rR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBPAGK7zwEiAAHtBCC2dqSo",
+  "EATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIAIQ0E4AYmtHigpBwD0BiO0+B4gABLQTgNjakaJCEHBP",
+  "AGK7zwEiAAHtBCC2dqSoEATcE4DY7nOACEBAOwGIrR0pKgQB9wQgtvscIIIeBDZu6LEBVq8hALHXIMECbgQe3MstIv7xDPIPERHG",
+  "TuDev2gSePs3Qnw8HTuNdO2H2Ok4YSvHBEhu+nt/Kl0gs3NC/PN/pds2xK0gdohZDbhNO0bTNS72kR2f",
+  "sdP1E2y1ikDs4qzCwe4txGaXEj8Cgti88wSxeeeHbXR//IRtaAhMEYDY6Aa5CHzwh1y7YSdLBCC2JdCh",
+  "HYbOOv8Rl57YphVis00N/8AuXuUfY6wRQuxYM6+h3Zfe11AJqjBCAGIbwRpHpb9TN4vQlByFHwGIzS8n",
+  "XkVEt3mi8CMAsfnlxKuISGyM2vxSBrH55cSriEhqjNr8Ugax+eXEu4gwavNLGcTmlxPvIqJR+2fvehd2",
+  "0AEbE3vTluGgwaFx7QTe/rUQdJYchQcBY2Jv3HIbjxYiCmsETqnvP+PLIb1xb7s95XdPe1e17hbGxB79",
+  "wl3rHhQrwiRAU/Jnfoyz5L2yu+0Oj8X+4p57erUP6wMkQCM25O6eWBuDnrER+0sQu3t2A177we8hd7f0",
+  "3mnBDWNij27fKb60B4+X7JbgkNeR3Cf+FZ+5O+XYxqBnTGxq0J59+zu1C8siIbA8Lce3wFYSvnf/3wob",
+  "V4yMir1v/yFh40TBCja84kaA5D71n0L85G2M3pSbg48cs5IiJXZi7OvydMnr0BPPWGkIDsKbAF3nppNq",
+  "v3yPd5wmo6PR2salLmqDElsaE5sOcPfYA0t/9BolbgI0ev/o50J851RTcHofSyGhbY3Wiml1UEoxmSSi",
+  "YhLwY99/Sfz91a+Iax/i1iSTnH2pe1lwivfPdwixW/3tGBFi67AvLcge56En/9HaaK2iqw7evCneKRTE",
+  "geyhpt+DpuTfe+EX4geP3eet3B+rp3LamkbG9DXIi+opLPRHhcQe+ZwQn1X/blU3LvbzY3ycGB58+Jia",
+  "tX6t2Ugr/238Vi7UamOJTM7ZON61j6a8ltsGIxwjLAIktcUpeBNeIo9IelWfm/mT+qxtZSIEucPquGjN",
+  "+gScSK3CKSby883LXY3kzPrh6V1DJxFoWo7LYHq5ojZeBFxJra5yTcpyuboktpQDb9jEArlt0saxbBNw",
+  "J7VqaVJ4ntq7JHaxXJ5QU3H1Z69AbnuscSR7BJxKrZpZFGKCWtuciqsXMhEnaYHNArlt0saxTBNwLbWQ",
+  "8jRNw6mdt8SmUTsRwuqUnAKA3EQBxXcCzqVW166LjZXB+ZbYBLY0NH9E/VOl1zYL5LZJG8fSTYCB1Oqz",
+  "tTy5PFpT+9rElvIz01JdA9Pd8DT1Qe40lLANNwIspFZT8FK5fLqVTZvYtKJ5Ik080bqRrdeQ2xZpHEcH",
+  "ARZSr5qCL7drjdi0orRh43NJklg/mUbHhtxEAYU7ATZSJ3K8dQq+zE0uv+j073xt5oSU8nindaaX4Q41",
+  "04RRf14C3KWmdnUVmzaA3EQBBQSaBHyQmiLtKTZtBLmJAkrsBHyRmvKUSmzaEHITBZRYCfCQOpkuJoXd",
+  "nT5Tr85Lx5Nnqzei90PlTSdwQq0TGSwLnQAXqcVi0vFEWSf+qUfs5Z0xci+TwL8xEOAkdWnz5sm0zDOL",
+  "TRVD7rR4sZ3PBHyVmpjnEpt2hNxEASVUAj5LTTnJLTbtDLmJAkrsBHyRmvKUSmzaEHITBZRYCfCQOpkuJoXd",
+  "AMXmnJLTbtDLmJAkpoBHyXmvLRl9hUwXztxmkpC9+k17YLr3LaJmz8e",
+  "pG4ytvoZe3Va6TP3TfUTJWp5dfU6G+9xQs0GZXvHgNQrrJ2O2Mth1Gq1yoBM1B1qGLmXmeDfbAQgdTsv",
+  "FmJTSJC7PTF4l54ApF7Lio3YFBrkXpsgLOlOAFJ35sNKbAoRcndOFJauJQCp1zJZXsJObAoMci+nB/+u",
+  "RwBSr0emuZyl2BQa5O6euJjXQure2WcrNoUOuXsnMLYtIHW6jLMWm5oAudMlMoatDj35jLj/G487byrd",
+  "++3iNtEsDWcvNjUGcmdJaZjbPnb8RbF3/yHnjfNBaoLkhdgUKOQmCnEWSJ09796ITU2D3NkT7PsekDpf",
+  "Bl0Sm5roWu7Z65+If/vht8X5N3+cjzj2SkWA7uN/8p/+Q4xuvyvV9iY38mX63crAO7EpeNdyUwzvvPmq",
+  "+OnLT4trH07RWxSNBO7/+uPirx75rti0ZVhjrfmq8lFqaqmXYlPgHOSmOCA4Uei/kMR7//JvxH1//big",
+  "0ZpDod+io5+t4hBL1hi8FZsaWr9xY5cYlPTccuf/a5+6+p64fOG8uHLxXfHxhx8I+q73zPXprPmIZvtt",
+  "d4wuCTz6hT8Td489IEbUlJvDCL2cAJ+lpjZ4LTY1gJPcFA+K/wR8l5oy4L3Y1AjITRRQdBAIQWriEITY",
+  "1BDITRRQ+iEQitTEIBixqTGQmyig5CEQktTU/qDEpgZBbqKAkoVAaFJT24MTmxoFuYkCShoCIUpN7Q5S",
+  "bGoY5CYKKN0IhCo1tTlYsalx9VrtsJDJK/QaBQTaCEgxWSyVx6WUQd5sELTYlEjI3dad8YYIBC51s4kR",
+  "pBpyR5DktE2MQOpoxKaGQu60PT/g7SKRmjIY/FS8tZtC7lYakb2OSGrKbFRiU4MhN1GIrEQmNWU3OrGp",
+  "0ZCbKERSIpSaMhul2NRwyE0UAi+RSk1Zdfozui67ValcPk1Px3AZA45tkEDEUhPVaMWmxtOzoSE3kQiu",
+  "VIsN+VCoN5+kyVa0U/FWOPO1mROqExxvXYbX3hKoFhM5Lsvlqrct0BA4xP4UYn1u9qh6+awGpqjCFYHI",
+  "p9+t2KOeireCKG3Y+JxYbOxWy6qty/HaFwKN50O+9ztrFiB2C7HS5s2TN9U0Tn3uPtOyGC9ZE0imC3Lg",
+  "odKGzUdj/ky9OkWYiq8m8un7hVptLJENNTWXu9bZBIudEkimk0Q8TzMtCL02ERB7LZO2JSR4QzQOSyke",
+  "VJIPt63EGxcEJtSM6h0I3R09xO7Op21tcxRPDijBdwrRIMkrkL0Nke43VSGSaSELk42byW+HpHwj9rPd",
+  "aQH/P0RzGOBNa7tyAAAAAElFTkSuQmCC"
+];
+var PISPI_AMBER_LOGO_DATA_URL = `data:image/png;base64,${AMBER_LOGO_SEGMENTS.join("")}`;
+var PISPI_QRCODE_LOGO_DATA_URL = `data:image/png;base64,${OCTO_QRCODE_LOGO_SEGMENTS.join("")}`;
+var DEFAULT_PISPI_LOGO_DATA_URL = PISPI_QRCODE_LOGO_DATA_URL;
+
+// src/qrcode/index.ts
+var cachedQrCodeModule = null;
+function resolveQrCodeModule(module) {
+  if (module?.create) {
+    return module;
+  }
+  if (module?.default?.create) {
+    return module.default;
+  }
+  throw new Error(`Le module "qrcode" n'expose pas l'API attendue.`);
+}
+async function getQrCodeModule() {
+  if (cachedQrCodeModule) {
+    return cachedQrCodeModule;
+  }
+  if (typeof window !== "undefined" && window.QRCode) {
+    const resolved2 = resolveQrCodeModule(window.QRCode);
+    cachedQrCodeModule = resolved2;
+    return resolved2;
+  }
+  const module = await import("qrcode");
+  const resolved = resolveQrCodeModule(module);
+  cachedQrCodeModule = resolved;
+  return resolved;
+}
+var DEFAULT_MERCHANT_CATEGORY_CODE = "0000";
+var DEFAULT_CURRENCY = "952";
+var DEFAULT_MERCHANT_NAME = "X";
+var DEFAULT_MERCHANT_CITY = "X";
+var DEFAULT_REFERENCE_LABEL_TAG = "05";
+var DEFAULT_MERCHANT_CHANNEL_TAG = "11";
+var DEFAULT_LOGO_SIZE_RATIO = 0.18;
+var DEFAULT_LOGO_PADDING_RATIO = 0;
+var DEFAULT_LOGO_BORDER_RADIUS_RATIO = 0.5;
+var DEFAULT_MARGIN = 0;
+var DEFAULT_SVG_SIZE = 400;
+var DEFAULT_DOT_COLOR = "#1A1A1A";
+var DEFAULT_BACKGROUND_COLOR = "#FFFFFF";
+var DOT_RADIUS_RATIO = 0.44;
+var FINDER_CORNER_RADIUS = 0.8;
+function createQrPayload(input, options = {}) {
+  const {
+    alias,
+    amount,
+    countryCode,
+    qrType,
+    referenceLabel
+  } = input;
+  if (!alias) {
+    throw new Error('Le param\xE8tre "alias" est obligatoire.');
+  }
+  validateAlias(alias);
+  if (!countryCode) {
+    throw new Error('Le param\xE8tre "countryCode" est obligatoire.');
+  }
+  validateCountryCode(countryCode);
+  if (!qrType) {
+    throw new Error('Le param\xE8tre "qrType" est obligatoire.');
+  }
+  if (!referenceLabel) {
+    throw new Error('Le param\xE8tre "referenceLabel" est obligatoire.');
+  }
+  validateReferenceLabel(referenceLabel);
+  if (amount !== void 0 && amount !== null && amount !== "") {
+    validateAmount(amount);
+  }
+  const payloadSegments = [];
+  payloadSegments.push(formatDataObject("00", "01"));
+  const merchantAccountInformation = [
+    formatDataObject("00", "int.bceao.pi"),
+    formatDataObject("01", alias)
+  ].join("");
+  payloadSegments.push(
+    formatDataObject("36", merchantAccountInformation),
+    formatDataObject("52", DEFAULT_MERCHANT_CATEGORY_CODE),
+    formatDataObject("53", DEFAULT_CURRENCY)
+  );
+  if (amount !== void 0 && amount !== null && amount !== "") {
+    payloadSegments.push(
+      formatDataObject("54", sanitizeAmount(amount))
+    );
+  }
+  payloadSegments.push(
+    formatDataObject("58", countryCode),
+    formatDataObject("59", DEFAULT_MERCHANT_NAME),
+    formatDataObject("60", DEFAULT_MERCHANT_CITY)
+  );
+  const normalizedQrType = normalizeQrType(qrType);
+  const additionalData = buildAdditionalData(
+    normalizedQrType,
+    referenceLabel,
+    options.additionalData
+  );
+  if (additionalData) {
+    payloadSegments.push(formatDataObject("62", additionalData));
+  }
+  const payloadWithoutCrc = payloadSegments.join("");
+  const crcInput = `${payloadWithoutCrc}6304`;
+  const crc = computeCrc16(crcInput);
+  return { payload: `${payloadWithoutCrc}6304${crc}` };
+}
+function buildAdditionalData(qrType, referenceLabel, overrides) {
+  const segments = [];
+  const referenceLabelTag = formatDataObject(
+    DEFAULT_REFERENCE_LABEL_TAG,
+    referenceLabel
+  );
+  segments.push(referenceLabelTag);
+  const merchantChannelValue = mapMerchantChannelFromType(qrType);
+  segments.push(
+    formatDataObject(DEFAULT_MERCHANT_CHANNEL_TAG, merchantChannelValue)
+  );
+  if (overrides?.purposeOfTransaction) {
+    segments.push(formatDataObject("12", overrides.purposeOfTransaction));
+  }
+  if (overrides?.custom) {
+    const entries = Object.entries(overrides.custom).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    for (const [tag, value] of entries) {
+      validateSubTag(tag);
+      segments.push(formatDataObject(tag, value));
+    }
+  }
+  return segments.join("");
+}
+function mapMerchantChannelFromType(value) {
+  return value === "DYNAMIC" ? "400" : "000";
+}
+function mapQrTypeFromChannel(channel) {
+  const normalized = channel?.trim().toUpperCase();
+  if (normalized === "400") {
+    return "DYNAMIC";
+  }
+  return "STATIC";
+}
+function formatDataObject(id, value) {
+  const length = value.length.toString().padStart(2, "0");
+  return `${id}${length}${value}`;
+}
+function sanitizeAmount(value) {
+  return typeof value === "number" ? value.toString() : value.trim();
+}
+function validateSubTag(tag) {
+  if (!/^[0-9A-Za-z]{2}$/.test(tag)) {
+    throw new Error(
+      `Le sous-tag additional data "${tag}" doit contenir exactement 2 caract\xE8res alphanum\xE9riques.`
+    );
+  }
+}
+function validateAlias(alias) {
+  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  if (!uuidV4Regex.test(alias)) {
+    throw new Error("L'alias doit \xEAtre un UUID v4 valide.");
+  }
+}
+function validateReferenceLabel(reference) {
+  if (reference.length > 25) {
+    throw new Error("Le referenceLabel ne doit pas d\xE9passer 25 caract\xE8res.");
+  }
+}
+function normalizeQrType(type) {
+  const normalized = type.trim().toUpperCase();
+  if (normalized === "STATIC" || normalized === "DYNAMIC") {
+    return normalized;
+  }
+  throw new Error('Le param\xE8tre "qrType" doit \xEAtre "STATIC" ou "DYNAMIC".');
+}
+var UEMOA_COUNTRIES = /* @__PURE__ */ new Set(["BJ", "BF", "CI", "ML", "NE", "SN", "TG", "GW"]);
+function validateCountryCode(code) {
+  if (!UEMOA_COUNTRIES.has(code.toUpperCase())) {
+    throw new Error("Le countryCode doit \xEAtre l'un des codes ISO2 de l'UEMOA (BJ, BF, CI, ML, NE, SN, TG, GW).");
+  }
+}
+function validateAmount(amount) {
+  const normalized = typeof amount === "number" ? amount.toString() : amount.trim();
+  if (!/^\d+$/.test(normalized)) {
+    throw new Error("Le montant doit contenir uniquement des chiffres.");
+  }
+  if (normalized.length > 13) {
+    throw new Error("Le montant ne doit pas d\xE9passer 13 chiffres.");
+  }
+}
+function computeCrc16(input) {
+  let crc = 65535;
+  const polynomial = 4129;
+  for (let i = 0; i < input.length; i += 1) {
+    crc ^= (input.codePointAt(i) ?? 0) << 8;
+    for (let j = 0; j < 8; j += 1) {
+      const hasHighBit = (crc & 32768) === 0;
+      crc = hasHighBit ? crc << 1 : crc << 1 ^ polynomial;
+      crc &= 65535;
+    }
+  }
+  return crc.toString(16).toUpperCase().padStart(4, "0");
+}
+function buildPayloadString(params, options) {
+  return createQrPayload(params, options).payload;
+}
+async function generateQrCodeSvg(input, options = {}) {
+  const { payload } = createQrPayload(input);
+  const size = options.size ?? DEFAULT_SVG_SIZE;
+  const margin = options.margin ?? DEFAULT_MARGIN;
+  const module = await getQrCodeModule();
+  const qr = module.create(payload, {
+    errorCorrectionLevel: "M"
+  });
+  const dotColor = options.dotColor ?? DEFAULT_DOT_COLOR;
+  const backgroundColor = options.backgroundColor ?? DEFAULT_BACKGROUND_COLOR;
+  return buildDotPatternSvg(qr, {
+    size,
+    margin,
+    dotColor,
+    backgroundColor,
+    logo: {
+      dataUrl: options.logoDataUrl ?? DEFAULT_PISPI_LOGO_DATA_URL,
+      sizeRatio: options.logoSizeRatio ?? DEFAULT_LOGO_SIZE_RATIO,
+      paddingRatio: options.logoPaddingRatio ?? DEFAULT_LOGO_PADDING_RATIO,
+      borderRadiusRatio: options.logoBorderRadiusRatio ?? DEFAULT_LOGO_BORDER_RADIUS_RATIO,
+      backgroundColor: options.logoBackgroundColor ?? DEFAULT_BACKGROUND_COLOR
+    }
+  });
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function formatSvgNumber(value) {
+  const normalized = Number.parseFloat(value.toFixed(3));
+  if (Number.isNaN(normalized)) {
+    return "0";
+  }
+  return normalized.toString();
+}
+var QRCode = {
+  // Original methods
+  createQrPayload,
+  buildPayloadString,
+  computeCrc16,
+  generateQrCodeSvg,
+  isValidPispiQrPayload,
+  // Simplified aliases
+  payload: buildPayloadString,
+  svg: generateQrCodeSvg,
+  validate: isValidPispiQrPayload,
+  raw: createQrPayload
+  // For when you need the object wrapper
+};
+var index_default = QRCode;
+function isValidPispiQrPayload(value) {
+  const basicErrors = validatePayloadBasics(value);
+  if (basicErrors.length > 0) {
+    return { valid: false, errors: basicErrors };
+  }
+  const { segments, errors: parseErrors } = parseEmvSegments(value);
+  if (parseErrors.length > 0) {
+    return { valid: false, errors: parseErrors };
+  }
+  const segmentValidation = validateSegmentContent(segments, value);
+  if (segmentValidation.errors.length > 0) {
+    return { valid: false, errors: segmentValidation.errors };
+  }
+  const data = buildValidationData(segments, segmentValidation);
+  return {
+    valid: true,
+    errors: [],
+    data
+  };
+}
+function validatePayloadBasics(value) {
+  if (!value) {
+    return ["La payload doit \xEAtre une cha\xEEne non vide."];
+  }
+  if (value.length < 12) {
+    return ["Payload trop courte pour contenir des segments EMV."];
+  }
+  return [];
+}
+function parseEmvSegments(value) {
+  const segments = {};
+  const errors = [];
+  let cursor = 0;
+  try {
+    while (cursor < value.length) {
+      const tag = value.slice(cursor, cursor + 2);
+      const lengthStr = value.slice(cursor + 2, cursor + 4);
+      const length = Number.parseInt(lengthStr, 10);
+      if (Number.isNaN(length) || length < 0) {
+        errors.push(`Longueur invalide pour le tag ${tag}.`);
+        break;
+      }
+      const valueStart = cursor + 4;
+      const valueEnd = valueStart + length;
+      if (valueEnd > value.length) {
+        errors.push(`Segment ${tag} tronqu\xE9.`);
+        break;
+      }
+      segments[tag] = value.slice(valueStart, valueEnd);
+      cursor = valueEnd;
+    }
+  } catch (error) {
+    errors.push(`Erreur lors de l'analyse de la payload: ${error?.message ?? error}`);
+  }
+  return { segments, errors };
+}
+function validateSegmentContent(segments, rawValue) {
+  const errors = [];
+  const formatErrors = validateFormatIndicator(segments["00"]);
+  const merchantInfoResult = extractMerchantInfo(segments["36"]);
+  const countryCodeResult = validateCountryCodeSegment(segments["58"]);
+  const additionalDataResult = extractAdditionalData(segments["62"]);
+  const crcErrors = validateCrcSegment(segments["63"], rawValue);
+  errors.push(
+    ...formatErrors,
+    ...merchantInfoResult.errors,
+    ...countryCodeResult.errors,
+    ...additionalDataResult.errors,
+    ...crcErrors
+  );
+  return {
+    errors,
+    merchantInfo: merchantInfoResult.merchantInfo,
+    referenceLabel: additionalDataResult.referenceLabel,
+    merchantChannel: additionalDataResult.merchantChannel,
+    countryCode: countryCodeResult.countryCode
+  };
+}
+function validateFormatIndicator(formatIndicator) {
+  if (!formatIndicator) {
+    return ["Tag 00 (format indicator) manquant."];
+  }
+  if (formatIndicator !== "01") {
+    return ["Tag 00 invalide (doit \xEAtre 01)."];
+  }
+  return [];
+}
+function extractMerchantInfo(segment) {
+  if (!segment) {
+    return {
+      merchantInfo: null,
+      errors: ["Tag 36 (Merchant Account Information) manquant."]
+    };
+  }
+  try {
+    const merchantInfo = parseSubFields(segment);
+    const errors = [];
+    if (!merchantInfo["01"]) {
+      errors.push("Alias manquant dans les informations marchand (tag 36).");
+    }
+    return { merchantInfo, errors };
+  } catch (error) {
+    return {
+      merchantInfo: null,
+      errors: [`Erreur lors de l'analyse des informations marchand: ${error?.message ?? error}`]
+    };
+  }
+}
+function validateCountryCodeSegment(countryCode) {
+  if (!countryCode) {
+    return {
+      errors: ["Tag 58 (Country Code) manquant."]
+    };
+  }
+  return {
+    countryCode,
+    errors: []
+  };
+}
+function extractAdditionalData(segment) {
+  if (!segment) {
+    return {
+      errors: ["Tag 62 (Additional Data Field) manquant."]
+    };
+  }
+  try {
+    const additionalSegments = parseSubFields(segment);
+    const referenceLabel = additionalSegments["05"];
+    const merchantChannel = additionalSegments[DEFAULT_MERCHANT_CHANNEL_TAG];
+    const errors = [];
+    if (!merchantChannel) {
+      errors.push("Tag 11 (Merchant Channel) manquant dans les donn\xE9es additionnelles.");
+    }
+    return {
+      referenceLabel,
+      merchantChannel,
+      errors
+    };
+  } catch (error) {
+    return {
+      errors: [`Erreur lors de l'analyse des donn\xE9es additionnelles: ${error?.message ?? error}`]
+    };
+  }
+}
+function validateCrcSegment(crc, rawValue) {
+  if (!crc) {
+    return ["Tag 63 (CRC) manquant."];
+  }
+  const payloadWithoutCrc = rawValue.slice(0, -4);
+  const computedCrc = computeCrc16(payloadWithoutCrc);
+  if (crc !== computedCrc) {
+    return ["CRC invalide."];
+  }
+  return [];
+}
+function buildValidationData(segments, context) {
+  const amountValue = segments["54"];
+  const data = {
+    alias: context.merchantInfo?.["01"] ?? "",
+    countryCode: context.countryCode ?? "",
+    qrType: mapQrTypeFromChannel(context.merchantChannel),
+    referenceLabel: context.referenceLabel ?? ""
+    // Chaîne vide si Tag 05 est absent (optionnel)
+  };
+  if (amountValue !== void 0) {
+    data.amount = amountValue;
+  }
+  return data;
+}
+function parseSubFields(data) {
+  const segments = {};
+  let cursor = 0;
+  while (cursor < data.length) {
+    const tag = data.slice(cursor, cursor + 2);
+    const lengthStr = data.slice(cursor + 2, cursor + 4);
+    const length = Number.parseInt(lengthStr, 10);
+    if (Number.isNaN(length) || length < 0) {
+      throw new Error(`Longueur invalide pour le sous-tag ${tag}`);
+    }
+    const valueStart = cursor + 4;
+    const valueEnd = valueStart + length;
+    if (valueEnd > data.length) {
+      throw new Error(`Sous-segment ${tag} tronqu\xE9`);
+    }
+    const segmentValue = data.slice(valueStart, valueEnd);
+    segments[tag] = segmentValue;
+    cursor = valueEnd;
+  }
+  return segments;
+}
+function buildDotPatternSvg(qr, options) {
+  const modules = qr.modules;
+  const moduleCount = typeof modules?.size === "number" ? modules.size : modules.length;
+  if (typeof moduleCount !== "number" || Number.isNaN(moduleCount)) {
+    throw new TypeError("Format du QR Code inattendu: impossible de d\xE9terminer la taille de la matrice.");
+  }
+  const svgSize = options.size;
+  const margin = options.margin;
+  const drawableSize = svgSize - margin * 2;
+  const cellSize = drawableSize / moduleCount;
+  const dotRadius = cellSize * DOT_RADIUS_RATIO;
+  const finderRadius = cellSize * FINDER_CORNER_RADIUS;
+  const paths = [];
+  const backgroundRect = `<rect fill="${options.backgroundColor}" width="${svgSize}" height="${svgSize}" rx="${formatSvgNumber(
+    finderRadius
+  )}" />`;
+  const finderSize = 7;
+  const finderOrigins = [
+    [0, 0],
+    [moduleCount - finderSize, 0],
+    [0, moduleCount - finderSize]
+  ];
+  for (const [fc, fr] of finderOrigins) {
+    paths.push(
+      ...generateFinderPatternRects(
+        margin + fc * cellSize,
+        margin + fr * cellSize,
+        cellSize,
+        options.dotColor,
+        options.backgroundColor
+      )
+    );
+  }
+  for (let row = 0; row < moduleCount; row += 1) {
+    for (let col = 0; col < moduleCount; col += 1) {
+      if (!isDarkModule(modules, moduleCount, row, col)) {
+        continue;
+      }
+      if (isFinderPattern(moduleCount, row, col)) {
+        continue;
+      }
+      const x = margin + col * cellSize + cellSize / 2;
+      const y = margin + row * cellSize + cellSize / 2;
+      paths.push(
+        `<circle cx="${formatSvgNumber(x)}" cy="${formatSvgNumber(y)}" r="${formatSvgNumber(
+          dotRadius
+        )}" fill="${options.dotColor}" />`
+      );
+    }
+  }
+  const logoSvg = generateLogoOverlay(
+    svgSize,
+    margin,
+    moduleCount,
+    cellSize,
+    options.logo
+  );
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 ${svgSize} ${svgSize}" shape-rendering="geometricPrecision">`,
+    backgroundRect,
+    ...paths,
+    logoSvg,
+    "</svg>"
+  ].join("");
+}
+function isFinderPattern(moduleCount, row, col) {
+  const patternSize = 7;
+  const inTop = row < patternSize;
+  const inBottom = row >= moduleCount - patternSize;
+  const inLeft = col < patternSize;
+  const inRight = col >= moduleCount - patternSize;
+  return inTop && inLeft || inTop && inRight || inBottom && inLeft;
+}
+function generateFinderPatternRects(originX, originY, cellSize, dotColor, backgroundColor) {
+  const fmt = formatSvgNumber;
+  const out7 = cellSize * 7;
+  const out5 = cellSize * 5;
+  const out3 = cellSize * 3;
+  const off1 = cellSize;
+  const off2 = cellSize * 2;
+  return [
+    `<rect x="${fmt(originX)}" y="${fmt(originY)}" width="${fmt(out7)}" height="${fmt(out7)}" fill="${dotColor}" />`,
+    `<rect x="${fmt(originX + off1)}" y="${fmt(originY + off1)}" width="${fmt(out5)}" height="${fmt(out5)}" fill="${backgroundColor}" />`,
+    `<rect x="${fmt(originX + off2)}" y="${fmt(originY + off2)}" width="${fmt(out3)}" height="${fmt(out3)}" fill="${dotColor}" />`
+  ];
+}
+function generateLogoOverlay(svgSize, margin, moduleCount, cellSize, logo) {
+  if (!logo.dataUrl) {
+    return "";
+  }
+  const qrDrawableSize = moduleCount * cellSize;
+  const logoSize = qrDrawableSize * clamp(logo.sizeRatio, 0.05, 0.5);
+  const logoPadding = logoSize * clamp(logo.paddingRatio, 0, 0.25);
+  const backgroundSize = logoSize + logoPadding * 2;
+  const logoBorderRadius = clamp(logo.borderRadiusRatio, 0, 0.5) * backgroundSize;
+  const originX = margin + (qrDrawableSize - backgroundSize) / 2;
+  const originY = margin + (qrDrawableSize - backgroundSize) / 2;
+  return [
+    `<g class="pispi-logo" transform="translate(${formatSvgNumber(originX)}, ${formatSvgNumber(originY)})" pointer-events="none">`,
+    `<rect width="${formatSvgNumber(backgroundSize)}" height="${formatSvgNumber(backgroundSize)}" rx="${formatSvgNumber(
+      logoBorderRadius
+    )}" fill="${logo.backgroundColor}" opacity="0.95"/>`,
+    `<image x="${formatSvgNumber(logoPadding)}" y="${formatSvgNumber(logoPadding)}" width="${formatSvgNumber(
+      logoSize
+    )}" height="${formatSvgNumber(logoSize)}" href="${logo.dataUrl}" xlink:href="${logo.dataUrl}" preserveAspectRatio="xMidYMid meet"/>`,
+    "</g>"
+  ].join("");
+}
+function isDarkModule(modules, moduleCount, row, col) {
+  if (modules?.data && Array.isArray(modules.data)) {
+    const index = row * moduleCount + col;
+    return Boolean(modules.data[index]);
+  }
+  if (typeof modules?.get === "function") {
+    return Boolean(modules.get(row, col));
+  }
+  if (Array.isArray(modules[row])) {
+    return Boolean(modules[row][col]);
+  }
+  return false;
+}
+export {
+  DEFAULT_PISPI_LOGO_DATA_URL,
+  PISPI_AMBER_LOGO_DATA_URL,
+  PISPI_QRCODE_LOGO_DATA_URL,
+  QRCode,
+  buildPayloadString,
+  computeCrc16,
+  createQrPayload,
+  index_default as default,
+  generateQrCodeSvg,
+  isValidPispiQrPayload
+};