@bounded-sh/client 0.0.1

package/dist/index.browser-DaNhOhkQ.esm.js

@@ -0,0 +1,4220 @@
+import { startScenario, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode } from '@solana-mobile/mobile-wallet-adapter-protocol';
+import { o as base58 } from './index.native-JPUkdHJj.esm.js';
+import 'axios';
+import '@solana/web3.js';
+import '@coral-xyz/anchor';
+import 'react';
+
+/** Name of the feature. */
+const SolanaSignAndSendTransaction = 'solana:signAndSendTransaction';
+
+/** Name of the feature. */
+const SolanaSignIn = 'solana:signIn';
+
+/** Name of the feature. */
+const SolanaSignMessage = 'solana:signMessage';
+
+/** Name of the feature. */
+const SolanaSignTransaction = 'solana:signTransaction';
+
+/** Name of the feature. */
+const StandardConnect = 'standard:connect';
+
+/** Name of the feature. */
+const StandardDisconnect = 'standard:disconnect';
+
+/** Name of the feature. */
+const StandardEvents = 'standard:events';
+
+var browser = {};
+
+var canPromise;
+var hasRequiredCanPromise;
+
+function requireCanPromise () {
+	if (hasRequiredCanPromise) return canPromise;
+	hasRequiredCanPromise = 1;
+	// can-promise has a crash in some versions of react native that dont have
+	// standard global objects
+	// https://github.com/soldair/node-qrcode/issues/157
+
+	canPromise = function () {
+	  return typeof Promise === 'function' && Promise.prototype && Promise.prototype.then
+	};
+	return canPromise;
+}
+
+var qrcode = {};
+
+var utils$1 = {};
+
+var hasRequiredUtils$1;
+
+function requireUtils$1 () {
+	if (hasRequiredUtils$1) return utils$1;
+	hasRequiredUtils$1 = 1;
+	let toSJISFunction;
+	const CODEWORDS_COUNT = [
+	  0, // Not used
+	  26, 44, 70, 100, 134, 172, 196, 242, 292, 346,
+	  404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,
+	  1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,
+	  2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706
+	];
+
+	/**
+	 * Returns the QR Code size for the specified version
+	 *
+	 * @param  {Number} version QR Code version
+	 * @return {Number}         size of QR code
+	 */
+	utils$1.getSymbolSize = function getSymbolSize (version) {
+	  if (!version) throw new Error('"version" cannot be null or undefined')
+	  if (version < 1 || version > 40) throw new Error('"version" should be in range from 1 to 40')
+	  return version * 4 + 17
+	};
+
+	/**
+	 * Returns the total number of codewords used to store data and EC information.
+	 *
+	 * @param  {Number} version QR Code version
+	 * @return {Number}         Data length in bits
+	 */
+	utils$1.getSymbolTotalCodewords = function getSymbolTotalCodewords (version) {
+	  return CODEWORDS_COUNT[version]
+	};
+
+	/**
+	 * Encode data with Bose-Chaudhuri-Hocquenghem
+	 *
+	 * @param  {Number} data Value to encode
+	 * @return {Number}      Encoded value
+	 */
+	utils$1.getBCHDigit = function (data) {
+	  let digit = 0;
+
+	  while (data !== 0) {
+	    digit++;
+	    data >>>= 1;
+	  }
+
+	  return digit
+	};
+
+	utils$1.setToSJISFunction = function setToSJISFunction (f) {
+	  if (typeof f !== 'function') {
+	    throw new Error('"toSJISFunc" is not a valid function.')
+	  }
+
+	  toSJISFunction = f;
+	};
+
+	utils$1.isKanjiModeEnabled = function () {
+	  return typeof toSJISFunction !== 'undefined'
+	};
+
+	utils$1.toSJIS = function toSJIS (kanji) {
+	  return toSJISFunction(kanji)
+	};
+	return utils$1;
+}
+
+var errorCorrectionLevel = {};
+
+var hasRequiredErrorCorrectionLevel;
+
+function requireErrorCorrectionLevel () {
+	if (hasRequiredErrorCorrectionLevel) return errorCorrectionLevel;
+	hasRequiredErrorCorrectionLevel = 1;
+	(function (exports$1) {
+		exports$1.L = { bit: 1 };
+		exports$1.M = { bit: 0 };
+		exports$1.Q = { bit: 3 };
+		exports$1.H = { bit: 2 };
+
+		function fromString (string) {
+		  if (typeof string !== 'string') {
+		    throw new Error('Param is not a string')
+		  }
+
+		  const lcStr = string.toLowerCase();
+
+		  switch (lcStr) {
+		    case 'l':
+		    case 'low':
+		      return exports$1.L
+
+		    case 'm':
+		    case 'medium':
+		      return exports$1.M
+
+		    case 'q':
+		    case 'quartile':
+		      return exports$1.Q
+
+		    case 'h':
+		    case 'high':
+		      return exports$1.H
+
+		    default:
+		      throw new Error('Unknown EC Level: ' + string)
+		  }
+		}
+
+		exports$1.isValid = function isValid (level) {
+		  return level && typeof level.bit !== 'undefined' &&
+		    level.bit >= 0 && level.bit < 4
+		};
+
+		exports$1.from = function from (value, defaultValue) {
+		  if (exports$1.isValid(value)) {
+		    return value
+		  }
+
+		  try {
+		    return fromString(value)
+		  } catch (e) {
+		    return defaultValue
+		  }
+		}; 
+	} (errorCorrectionLevel));
+	return errorCorrectionLevel;
+}
+
+var bitBuffer;
+var hasRequiredBitBuffer;
+
+function requireBitBuffer () {
+	if (hasRequiredBitBuffer) return bitBuffer;
+	hasRequiredBitBuffer = 1;
+	function BitBuffer () {
+	  this.buffer = [];
+	  this.length = 0;
+	}
+
+	BitBuffer.prototype = {
+
+	  get: function (index) {
+	    const bufIndex = Math.floor(index / 8);
+	    return ((this.buffer[bufIndex] >>> (7 - index % 8)) & 1) === 1
+	  },
+
+	  put: function (num, length) {
+	    for (let i = 0; i < length; i++) {
+	      this.putBit(((num >>> (length - i - 1)) & 1) === 1);
+	    }
+	  },
+
+	  getLengthInBits: function () {
+	    return this.length
+	  },
+
+	  putBit: function (bit) {
+	    const bufIndex = Math.floor(this.length / 8);
+	    if (this.buffer.length <= bufIndex) {
+	      this.buffer.push(0);
+	    }
+
+	    if (bit) {
+	      this.buffer[bufIndex] |= (0x80 >>> (this.length % 8));
+	    }
+
+	    this.length++;
+	  }
+	};
+
+	bitBuffer = BitBuffer;
+	return bitBuffer;
+}
+
+/**
+ * Helper class to handle QR Code symbol modules
+ *
+ * @param {Number} size Symbol size
+ */
+
+var bitMatrix;
+var hasRequiredBitMatrix;
+
+function requireBitMatrix () {
+	if (hasRequiredBitMatrix) return bitMatrix;
+	hasRequiredBitMatrix = 1;
+	function BitMatrix (size) {
+	  if (!size || size < 1) {
+	    throw new Error('BitMatrix size must be defined and greater than 0')
+	  }
+
+	  this.size = size;
+	  this.data = new Uint8Array(size * size);
+	  this.reservedBit = new Uint8Array(size * size);
+	}
+
+	/**
+	 * Set bit value at specified location
+	 * If reserved flag is set, this bit will be ignored during masking process
+	 *
+	 * @param {Number}  row
+	 * @param {Number}  col
+	 * @param {Boolean} value
+	 * @param {Boolean} reserved
+	 */
+	BitMatrix.prototype.set = function (row, col, value, reserved) {
+	  const index = row * this.size + col;
+	  this.data[index] = value;
+	  if (reserved) this.reservedBit[index] = true;
+	};
+
+	/**
+	 * Returns bit value at specified location
+	 *
+	 * @param  {Number}  row
+	 * @param  {Number}  col
+	 * @return {Boolean}
+	 */
+	BitMatrix.prototype.get = function (row, col) {
+	  return this.data[row * this.size + col]
+	};
+
+	/**
+	 * Applies xor operator at specified location
+	 * (used during masking process)
+	 *
+	 * @param {Number}  row
+	 * @param {Number}  col
+	 * @param {Boolean} value
+	 */
+	BitMatrix.prototype.xor = function (row, col, value) {
+	  this.data[row * this.size + col] ^= value;
+	};
+
+	/**
+	 * Check if bit at specified location is reserved
+	 *
+	 * @param {Number}   row
+	 * @param {Number}   col
+	 * @return {Boolean}
+	 */
+	BitMatrix.prototype.isReserved = function (row, col) {
+	  return this.reservedBit[row * this.size + col]
+	};
+
+	bitMatrix = BitMatrix;
+	return bitMatrix;
+}
+
+var alignmentPattern = {};
+
+/**
+ * Alignment pattern are fixed reference pattern in defined positions
+ * in a matrix symbology, which enables the decode software to re-synchronise
+ * the coordinate mapping of the image modules in the event of moderate amounts
+ * of distortion of the image.
+ *
+ * Alignment patterns are present only in QR Code symbols of version 2 or larger
+ * and their number depends on the symbol version.
+ */
+
+var hasRequiredAlignmentPattern;
+
+function requireAlignmentPattern () {
+	if (hasRequiredAlignmentPattern) return alignmentPattern;
+	hasRequiredAlignmentPattern = 1;
+	(function (exports$1) {
+		const getSymbolSize = requireUtils$1().getSymbolSize;
+
+		/**
+		 * Calculate the row/column coordinates of the center module of each alignment pattern
+		 * for the specified QR Code version.
+		 *
+		 * The alignment patterns are positioned symmetrically on either side of the diagonal
+		 * running from the top left corner of the symbol to the bottom right corner.
+		 *
+		 * Since positions are simmetrical only half of the coordinates are returned.
+		 * Each item of the array will represent in turn the x and y coordinate.
+		 * @see {@link getPositions}
+		 *
+		 * @param  {Number} version QR Code version
+		 * @return {Array}          Array of coordinate
+		 */
+		exports$1.getRowColCoords = function getRowColCoords (version) {
+		  if (version === 1) return []
+
+		  const posCount = Math.floor(version / 7) + 2;
+		  const size = getSymbolSize(version);
+		  const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
+		  const positions = [size - 7]; // Last coord is always (size - 7)
+
+		  for (let i = 1; i < posCount - 1; i++) {
+		    positions[i] = positions[i - 1] - intervals;
+		  }
+
+		  positions.push(6); // First coord is always 6
+
+		  return positions.reverse()
+		};
+
+		/**
+		 * Returns an array containing the positions of each alignment pattern.
+		 * Each array's element represent the center point of the pattern as (x, y) coordinates
+		 *
+		 * Coordinates are calculated expanding the row/column coordinates returned by {@link getRowColCoords}
+		 * and filtering out the items that overlaps with finder pattern
+		 *
+		 * @example
+		 * For a Version 7 symbol {@link getRowColCoords} returns values 6, 22 and 38.
+		 * The alignment patterns, therefore, are to be centered on (row, column)
+		 * positions (6,22), (22,6), (22,22), (22,38), (38,22), (38,38).
+		 * Note that the coordinates (6,6), (6,38), (38,6) are occupied by finder patterns
+		 * and are not therefore used for alignment patterns.
+		 *
+		 * let pos = getPositions(7)
+		 * // [[6,22], [22,6], [22,22], [22,38], [38,22], [38,38]]
+		 *
+		 * @param  {Number} version QR Code version
+		 * @return {Array}          Array of coordinates
+		 */
+		exports$1.getPositions = function getPositions (version) {
+		  const coords = [];
+		  const pos = exports$1.getRowColCoords(version);
+		  const posLength = pos.length;
+
+		  for (let i = 0; i < posLength; i++) {
+		    for (let j = 0; j < posLength; j++) {
+		      // Skip if position is occupied by finder patterns
+		      if ((i === 0 && j === 0) || // top-left
+		          (i === 0 && j === posLength - 1) || // bottom-left
+		          (i === posLength - 1 && j === 0)) { // top-right
+		        continue
+		      }
+
+		      coords.push([pos[i], pos[j]]);
+		    }
+		  }
+
+		  return coords
+		}; 
+	} (alignmentPattern));
+	return alignmentPattern;
+}
+
+var finderPattern = {};
+
+var hasRequiredFinderPattern;
+
+function requireFinderPattern () {
+	if (hasRequiredFinderPattern) return finderPattern;
+	hasRequiredFinderPattern = 1;
+	const getSymbolSize = requireUtils$1().getSymbolSize;
+	const FINDER_PATTERN_SIZE = 7;
+
+	/**
+	 * Returns an array containing the positions of each finder pattern.
+	 * Each array's element represent the top-left point of the pattern as (x, y) coordinates
+	 *
+	 * @param  {Number} version QR Code version
+	 * @return {Array}          Array of coordinates
+	 */
+	finderPattern.getPositions = function getPositions (version) {
+	  const size = getSymbolSize(version);
+
+	  return [
+	    // top-left
+	    [0, 0],
+	    // top-right
+	    [size - FINDER_PATTERN_SIZE, 0],
+	    // bottom-left
+	    [0, size - FINDER_PATTERN_SIZE]
+	  ]
+	};
+	return finderPattern;
+}
+
+var maskPattern = {};
+
+/**
+ * Data mask pattern reference
+ * @type {Object}
+ */
+
+var hasRequiredMaskPattern;
+
+function requireMaskPattern () {
+	if (hasRequiredMaskPattern) return maskPattern;
+	hasRequiredMaskPattern = 1;
+	(function (exports$1) {
+		exports$1.Patterns = {
+		  PATTERN000: 0,
+		  PATTERN001: 1,
+		  PATTERN010: 2,
+		  PATTERN011: 3,
+		  PATTERN100: 4,
+		  PATTERN101: 5,
+		  PATTERN110: 6,
+		  PATTERN111: 7
+		};
+
+		/**
+		 * Weighted penalty scores for the undesirable features
+		 * @type {Object}
+		 */
+		const PenaltyScores = {
+		  N1: 3,
+		  N2: 3,
+		  N3: 40,
+		  N4: 10
+		};
+
+		/**
+		 * Check if mask pattern value is valid
+		 *
+		 * @param  {Number}  mask    Mask pattern
+		 * @return {Boolean}         true if valid, false otherwise
+		 */
+		exports$1.isValid = function isValid (mask) {
+		  return mask != null && mask !== '' && !isNaN(mask) && mask >= 0 && mask <= 7
+		};
+
+		/**
+		 * Returns mask pattern from a value.
+		 * If value is not valid, returns undefined
+		 *
+		 * @param  {Number|String} value        Mask pattern value
+		 * @return {Number}                     Valid mask pattern or undefined
+		 */
+		exports$1.from = function from (value) {
+		  return exports$1.isValid(value) ? parseInt(value, 10) : undefined
+		};
+
+		/**
+		* Find adjacent modules in row/column with the same color
+		* and assign a penalty value.
+		*
+		* Points: N1 + i
+		* i is the amount by which the number of adjacent modules of the same color exceeds 5
+		*/
+		exports$1.getPenaltyN1 = function getPenaltyN1 (data) {
+		  const size = data.size;
+		  let points = 0;
+		  let sameCountCol = 0;
+		  let sameCountRow = 0;
+		  let lastCol = null;
+		  let lastRow = null;
+
+		  for (let row = 0; row < size; row++) {
+		    sameCountCol = sameCountRow = 0;
+		    lastCol = lastRow = null;
+
+		    for (let col = 0; col < size; col++) {
+		      let module = data.get(row, col);
+		      if (module === lastCol) {
+		        sameCountCol++;
+		      } else {
+		        if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+		        lastCol = module;
+		        sameCountCol = 1;
+		      }
+
+		      module = data.get(col, row);
+		      if (module === lastRow) {
+		        sameCountRow++;
+		      } else {
+		        if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+		        lastRow = module;
+		        sameCountRow = 1;
+		      }
+		    }
+
+		    if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+		    if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+		  }
+
+		  return points
+		};
+
+		/**
+		 * Find 2x2 blocks with the same color and assign a penalty value
+		 *
+		 * Points: N2 * (m - 1) * (n - 1)
+		 */
+		exports$1.getPenaltyN2 = function getPenaltyN2 (data) {
+		  const size = data.size;
+		  let points = 0;
+
+		  for (let row = 0; row < size - 1; row++) {
+		    for (let col = 0; col < size - 1; col++) {
+		      const last = data.get(row, col) +
+		        data.get(row, col + 1) +
+		        data.get(row + 1, col) +
+		        data.get(row + 1, col + 1);
+
+		      if (last === 4 || last === 0) points++;
+		    }
+		  }
+
+		  return points * PenaltyScores.N2
+		};
+
+		/**
+		 * Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,
+		 * preceded or followed by light area 4 modules wide
+		 *
+		 * Points: N3 * number of pattern found
+		 */
+		exports$1.getPenaltyN3 = function getPenaltyN3 (data) {
+		  const size = data.size;
+		  let points = 0;
+		  let bitsCol = 0;
+		  let bitsRow = 0;
+
+		  for (let row = 0; row < size; row++) {
+		    bitsCol = bitsRow = 0;
+		    for (let col = 0; col < size; col++) {
+		      bitsCol = ((bitsCol << 1) & 0x7FF) | data.get(row, col);
+		      if (col >= 10 && (bitsCol === 0x5D0 || bitsCol === 0x05D)) points++;
+
+		      bitsRow = ((bitsRow << 1) & 0x7FF) | data.get(col, row);
+		      if (col >= 10 && (bitsRow === 0x5D0 || bitsRow === 0x05D)) points++;
+		    }
+		  }
+
+		  return points * PenaltyScores.N3
+		};
+
+		/**
+		 * Calculate proportion of dark modules in entire symbol
+		 *
+		 * Points: N4 * k
+		 *
+		 * k is the rating of the deviation of the proportion of dark modules
+		 * in the symbol from 50% in steps of 5%
+		 */
+		exports$1.getPenaltyN4 = function getPenaltyN4 (data) {
+		  let darkCount = 0;
+		  const modulesCount = data.data.length;
+
+		  for (let i = 0; i < modulesCount; i++) darkCount += data.data[i];
+
+		  const k = Math.abs(Math.ceil((darkCount * 100 / modulesCount) / 5) - 10);
+
+		  return k * PenaltyScores.N4
+		};
+
+		/**
+		 * Return mask value at given position
+		 *
+		 * @param  {Number} maskPattern Pattern reference value
+		 * @param  {Number} i           Row
+		 * @param  {Number} j           Column
+		 * @return {Boolean}            Mask value
+		 */
+		function getMaskAt (maskPattern, i, j) {
+		  switch (maskPattern) {
+		    case exports$1.Patterns.PATTERN000: return (i + j) % 2 === 0
+		    case exports$1.Patterns.PATTERN001: return i % 2 === 0
+		    case exports$1.Patterns.PATTERN010: return j % 3 === 0
+		    case exports$1.Patterns.PATTERN011: return (i + j) % 3 === 0
+		    case exports$1.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0
+		    case exports$1.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0
+		    case exports$1.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0
+		    case exports$1.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0
+
+		    default: throw new Error('bad maskPattern:' + maskPattern)
+		  }
+		}
+
+		/**
+		 * Apply a mask pattern to a BitMatrix
+		 *
+		 * @param  {Number}    pattern Pattern reference number
+		 * @param  {BitMatrix} data    BitMatrix data
+		 */
+		exports$1.applyMask = function applyMask (pattern, data) {
+		  const size = data.size;
+
+		  for (let col = 0; col < size; col++) {
+		    for (let row = 0; row < size; row++) {
+		      if (data.isReserved(row, col)) continue
+		      data.xor(row, col, getMaskAt(pattern, row, col));
+		    }
+		  }
+		};
+
+		/**
+		 * Returns the best mask pattern for data
+		 *
+		 * @param  {BitMatrix} data
+		 * @return {Number} Mask pattern reference number
+		 */
+		exports$1.getBestMask = function getBestMask (data, setupFormatFunc) {
+		  const numPatterns = Object.keys(exports$1.Patterns).length;
+		  let bestPattern = 0;
+		  let lowerPenalty = Infinity;
+
+		  for (let p = 0; p < numPatterns; p++) {
+		    setupFormatFunc(p);
+		    exports$1.applyMask(p, data);
+
+		    // Calculate penalty
+		    const penalty =
+		      exports$1.getPenaltyN1(data) +
+		      exports$1.getPenaltyN2(data) +
+		      exports$1.getPenaltyN3(data) +
+		      exports$1.getPenaltyN4(data);
+
+		    // Undo previously applied mask
+		    exports$1.applyMask(p, data);
+
+		    if (penalty < lowerPenalty) {
+		      lowerPenalty = penalty;
+		      bestPattern = p;
+		    }
+		  }
+
+		  return bestPattern
+		}; 
+	} (maskPattern));
+	return maskPattern;
+}
+
+var errorCorrectionCode = {};
+
+var hasRequiredErrorCorrectionCode;
+
+function requireErrorCorrectionCode () {
+	if (hasRequiredErrorCorrectionCode) return errorCorrectionCode;
+	hasRequiredErrorCorrectionCode = 1;
+	const ECLevel = requireErrorCorrectionLevel();
+
+	const EC_BLOCKS_TABLE = [
+	// L  M  Q  H
+	  1, 1, 1, 1,
+	  1, 1, 1, 1,
+	  1, 1, 2, 2,
+	  1, 2, 2, 4,
+	  1, 2, 4, 4,
+	  2, 4, 4, 4,
+	  2, 4, 6, 5,
+	  2, 4, 6, 6,
+	  2, 5, 8, 8,
+	  4, 5, 8, 8,
+	  4, 5, 8, 11,
+	  4, 8, 10, 11,
+	  4, 9, 12, 16,
+	  4, 9, 16, 16,
+	  6, 10, 12, 18,
+	  6, 10, 17, 16,
+	  6, 11, 16, 19,
+	  6, 13, 18, 21,
+	  7, 14, 21, 25,
+	  8, 16, 20, 25,
+	  8, 17, 23, 25,
+	  9, 17, 23, 34,
+	  9, 18, 25, 30,
+	  10, 20, 27, 32,
+	  12, 21, 29, 35,
+	  12, 23, 34, 37,
+	  12, 25, 34, 40,
+	  13, 26, 35, 42,
+	  14, 28, 38, 45,
+	  15, 29, 40, 48,
+	  16, 31, 43, 51,
+	  17, 33, 45, 54,
+	  18, 35, 48, 57,
+	  19, 37, 51, 60,
+	  19, 38, 53, 63,
+	  20, 40, 56, 66,
+	  21, 43, 59, 70,
+	  22, 45, 62, 74,
+	  24, 47, 65, 77,
+	  25, 49, 68, 81
+	];
+
+	const EC_CODEWORDS_TABLE = [
+	// L  M  Q  H
+	  7, 10, 13, 17,
+	  10, 16, 22, 28,
+	  15, 26, 36, 44,
+	  20, 36, 52, 64,
+	  26, 48, 72, 88,
+	  36, 64, 96, 112,
+	  40, 72, 108, 130,
+	  48, 88, 132, 156,
+	  60, 110, 160, 192,
+	  72, 130, 192, 224,
+	  80, 150, 224, 264,
+	  96, 176, 260, 308,
+	  104, 198, 288, 352,
+	  120, 216, 320, 384,
+	  132, 240, 360, 432,
+	  144, 280, 408, 480,
+	  168, 308, 448, 532,
+	  180, 338, 504, 588,
+	  196, 364, 546, 650,
+	  224, 416, 600, 700,
+	  224, 442, 644, 750,
+	  252, 476, 690, 816,
+	  270, 504, 750, 900,
+	  300, 560, 810, 960,
+	  312, 588, 870, 1050,
+	  336, 644, 952, 1110,
+	  360, 700, 1020, 1200,
+	  390, 728, 1050, 1260,
+	  420, 784, 1140, 1350,
+	  450, 812, 1200, 1440,
+	  480, 868, 1290, 1530,
+	  510, 924, 1350, 1620,
+	  540, 980, 1440, 1710,
+	  570, 1036, 1530, 1800,
+	  570, 1064, 1590, 1890,
+	  600, 1120, 1680, 1980,
+	  630, 1204, 1770, 2100,
+	  660, 1260, 1860, 2220,
+	  720, 1316, 1950, 2310,
+	  750, 1372, 2040, 2430
+	];
+
+	/**
+	 * Returns the number of error correction block that the QR Code should contain
+	 * for the specified version and error correction level.
+	 *
+	 * @param  {Number} version              QR Code version
+	 * @param  {Number} errorCorrectionLevel Error correction level
+	 * @return {Number}                      Number of error correction blocks
+	 */
+	errorCorrectionCode.getBlocksCount = function getBlocksCount (version, errorCorrectionLevel) {
+	  switch (errorCorrectionLevel) {
+	    case ECLevel.L:
+	      return EC_BLOCKS_TABLE[(version - 1) * 4 + 0]
+	    case ECLevel.M:
+	      return EC_BLOCKS_TABLE[(version - 1) * 4 + 1]
+	    case ECLevel.Q:
+	      return EC_BLOCKS_TABLE[(version - 1) * 4 + 2]
+	    case ECLevel.H:
+	      return EC_BLOCKS_TABLE[(version - 1) * 4 + 3]
+	    default:
+	      return undefined
+	  }
+	};
+
+	/**
+	 * Returns the number of error correction codewords to use for the specified
+	 * version and error correction level.
+	 *
+	 * @param  {Number} version              QR Code version
+	 * @param  {Number} errorCorrectionLevel Error correction level
+	 * @return {Number}                      Number of error correction codewords
+	 */
+	errorCorrectionCode.getTotalCodewordsCount = function getTotalCodewordsCount (version, errorCorrectionLevel) {
+	  switch (errorCorrectionLevel) {
+	    case ECLevel.L:
+	      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0]
+	    case ECLevel.M:
+	      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1]
+	    case ECLevel.Q:
+	      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2]
+	    case ECLevel.H:
+	      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3]
+	    default:
+	      return undefined
+	  }
+	};
+	return errorCorrectionCode;
+}
+
+var polynomial = {};
+
+var galoisField = {};
+
+var hasRequiredGaloisField;
+
+function requireGaloisField () {
+	if (hasRequiredGaloisField) return galoisField;
+	hasRequiredGaloisField = 1;
+	const EXP_TABLE = new Uint8Array(512);
+	const LOG_TABLE = new Uint8Array(256)
+	/**
+	 * Precompute the log and anti-log tables for faster computation later
+	 *
+	 * For each possible value in the galois field 2^8, we will pre-compute
+	 * the logarithm and anti-logarithm (exponential) of this value
+	 *
+	 * ref {@link https://en.wikiversity.org/wiki/Reed%E2%80%93Solomon_codes_for_coders#Introduction_to_mathematical_fields}
+	 */
+	;(function initTables () {
+	  let x = 1;
+	  for (let i = 0; i < 255; i++) {
+	    EXP_TABLE[i] = x;
+	    LOG_TABLE[x] = i;
+
+	    x <<= 1; // multiply by 2
+
+	    // The QR code specification says to use byte-wise modulo 100011101 arithmetic.
+	    // This means that when a number is 256 or larger, it should be XORed with 0x11D.
+	    if (x & 0x100) { // similar to x >= 256, but a lot faster (because 0x100 == 256)
+	      x ^= 0x11D;
+	    }
+	  }
+
+	  // Optimization: double the size of the anti-log table so that we don't need to mod 255 to
+	  // stay inside the bounds (because we will mainly use this table for the multiplication of
+	  // two GF numbers, no more).
+	  // @see {@link mul}
+	  for (let i = 255; i < 512; i++) {
+	    EXP_TABLE[i] = EXP_TABLE[i - 255];
+	  }
+	}());
+
+	/**
+	 * Returns log value of n inside Galois Field
+	 *
+	 * @param  {Number} n
+	 * @return {Number}
+	 */
+	galoisField.log = function log (n) {
+	  if (n < 1) throw new Error('log(' + n + ')')
+	  return LOG_TABLE[n]
+	};
+
+	/**
+	 * Returns anti-log value of n inside Galois Field
+	 *
+	 * @param  {Number} n
+	 * @return {Number}
+	 */
+	galoisField.exp = function exp (n) {
+	  return EXP_TABLE[n]
+	};
+
+	/**
+	 * Multiplies two number inside Galois Field
+	 *
+	 * @param  {Number} x
+	 * @param  {Number} y
+	 * @return {Number}
+	 */
+	galoisField.mul = function mul (x, y) {
+	  if (x === 0 || y === 0) return 0
+
+	  // should be EXP_TABLE[(LOG_TABLE[x] + LOG_TABLE[y]) % 255] if EXP_TABLE wasn't oversized
+	  // @see {@link initTables}
+	  return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]]
+	};
+	return galoisField;
+}
+
+var hasRequiredPolynomial;
+
+function requirePolynomial () {
+	if (hasRequiredPolynomial) return polynomial;
+	hasRequiredPolynomial = 1;
+	(function (exports$1) {
+		const GF = requireGaloisField();
+
+		/**
+		 * Multiplies two polynomials inside Galois Field
+		 *
+		 * @param  {Uint8Array} p1 Polynomial
+		 * @param  {Uint8Array} p2 Polynomial
+		 * @return {Uint8Array}    Product of p1 and p2
+		 */
+		exports$1.mul = function mul (p1, p2) {
+		  const coeff = new Uint8Array(p1.length + p2.length - 1);
+
+		  for (let i = 0; i < p1.length; i++) {
+		    for (let j = 0; j < p2.length; j++) {
+		      coeff[i + j] ^= GF.mul(p1[i], p2[j]);
+		    }
+		  }
+
+		  return coeff
+		};
+
+		/**
+		 * Calculate the remainder of polynomials division
+		 *
+		 * @param  {Uint8Array} divident Polynomial
+		 * @param  {Uint8Array} divisor  Polynomial
+		 * @return {Uint8Array}          Remainder
+		 */
+		exports$1.mod = function mod (divident, divisor) {
+		  let result = new Uint8Array(divident);
+
+		  while ((result.length - divisor.length) >= 0) {
+		    const coeff = result[0];
+
+		    for (let i = 0; i < divisor.length; i++) {
+		      result[i] ^= GF.mul(divisor[i], coeff);
+		    }
+
+		    // remove all zeros from buffer head
+		    let offset = 0;
+		    while (offset < result.length && result[offset] === 0) offset++;
+		    result = result.slice(offset);
+		  }
+
+		  return result
+		};
+
+		/**
+		 * Generate an irreducible generator polynomial of specified degree
+		 * (used by Reed-Solomon encoder)
+		 *
+		 * @param  {Number} degree Degree of the generator polynomial
+		 * @return {Uint8Array}    Buffer containing polynomial coefficients
+		 */
+		exports$1.generateECPolynomial = function generateECPolynomial (degree) {
+		  let poly = new Uint8Array([1]);
+		  for (let i = 0; i < degree; i++) {
+		    poly = exports$1.mul(poly, new Uint8Array([1, GF.exp(i)]));
+		  }
+
+		  return poly
+		}; 
+	} (polynomial));
+	return polynomial;
+}
+
+var reedSolomonEncoder;
+var hasRequiredReedSolomonEncoder;
+
+function requireReedSolomonEncoder () {
+	if (hasRequiredReedSolomonEncoder) return reedSolomonEncoder;
+	hasRequiredReedSolomonEncoder = 1;
+	const Polynomial = requirePolynomial();
+
+	function ReedSolomonEncoder (degree) {
+	  this.genPoly = undefined;
+	  this.degree = degree;
+
+	  if (this.degree) this.initialize(this.degree);
+	}
+
+	/**
+	 * Initialize the encoder.
+	 * The input param should correspond to the number of error correction codewords.
+	 *
+	 * @param  {Number} degree
+	 */
+	ReedSolomonEncoder.prototype.initialize = function initialize (degree) {
+	  // create an irreducible generator polynomial
+	  this.degree = degree;
+	  this.genPoly = Polynomial.generateECPolynomial(this.degree);
+	};
+
+	/**
+	 * Encodes a chunk of data
+	 *
+	 * @param  {Uint8Array} data Buffer containing input data
+	 * @return {Uint8Array}      Buffer containing encoded data
+	 */
+	ReedSolomonEncoder.prototype.encode = function encode (data) {
+	  if (!this.genPoly) {
+	    throw new Error('Encoder not initialized')
+	  }
+
+	  // Calculate EC for this data block
+	  // extends data size to data+genPoly size
+	  const paddedData = new Uint8Array(data.length + this.degree);
+	  paddedData.set(data);
+
+	  // The error correction codewords are the remainder after dividing the data codewords
+	  // by a generator polynomial
+	  const remainder = Polynomial.mod(paddedData, this.genPoly);
+
+	  // return EC data blocks (last n byte, where n is the degree of genPoly)
+	  // If coefficients number in remainder are less than genPoly degree,
+	  // pad with 0s to the left to reach the needed number of coefficients
+	  const start = this.degree - remainder.length;
+	  if (start > 0) {
+	    const buff = new Uint8Array(this.degree);
+	    buff.set(remainder, start);
+
+	    return buff
+	  }
+
+	  return remainder
+	};
+
+	reedSolomonEncoder = ReedSolomonEncoder;
+	return reedSolomonEncoder;
+}
+
+var version = {};
+
+var mode = {};
+
+var versionCheck = {};
+
+/**
+ * Check if QR Code version is valid
+ *
+ * @param  {Number}  version QR Code version
+ * @return {Boolean}         true if valid version, false otherwise
+ */
+
+var hasRequiredVersionCheck;
+
+function requireVersionCheck () {
+	if (hasRequiredVersionCheck) return versionCheck;
+	hasRequiredVersionCheck = 1;
+	versionCheck.isValid = function isValid (version) {
+	  return !isNaN(version) && version >= 1 && version <= 40
+	};
+	return versionCheck;
+}
+
+var regex = {};
+
+var hasRequiredRegex;
+
+function requireRegex () {
+	if (hasRequiredRegex) return regex;
+	hasRequiredRegex = 1;
+	const numeric = '[0-9]+';
+	const alphanumeric = '[A-Z $%*+\\-./:]+';
+	let kanji = '(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|' +
+	  '[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|' +
+	  '[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|' +
+	  '[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+';
+	kanji = kanji.replace(/u/g, '\\u');
+
+	const byte = '(?:(?![A-Z0-9 $%*+\\-./:]|' + kanji + ')(?:.|[\r\n]))+';
+
+	regex.KANJI = new RegExp(kanji, 'g');
+	regex.BYTE_KANJI = new RegExp('[^A-Z0-9 $%*+\\-./:]+', 'g');
+	regex.BYTE = new RegExp(byte, 'g');
+	regex.NUMERIC = new RegExp(numeric, 'g');
+	regex.ALPHANUMERIC = new RegExp(alphanumeric, 'g');
+
+	const TEST_KANJI = new RegExp('^' + kanji + '$');
+	const TEST_NUMERIC = new RegExp('^' + numeric + '$');
+	const TEST_ALPHANUMERIC = new RegExp('^[A-Z0-9 $%*+\\-./:]+$');
+
+	regex.testKanji = function testKanji (str) {
+	  return TEST_KANJI.test(str)
+	};
+
+	regex.testNumeric = function testNumeric (str) {
+	  return TEST_NUMERIC.test(str)
+	};
+
+	regex.testAlphanumeric = function testAlphanumeric (str) {
+	  return TEST_ALPHANUMERIC.test(str)
+	};
+	return regex;
+}
+
+var hasRequiredMode;
+
+function requireMode () {
+	if (hasRequiredMode) return mode;
+	hasRequiredMode = 1;
+	(function (exports$1) {
+		const VersionCheck = requireVersionCheck();
+		const Regex = requireRegex();
+
+		/**
+		 * Numeric mode encodes data from the decimal digit set (0 - 9)
+		 * (byte values 30HEX to 39HEX).
+		 * Normally, 3 data characters are represented by 10 bits.
+		 *
+		 * @type {Object}
+		 */
+		exports$1.NUMERIC = {
+		  id: 'Numeric',
+		  bit: 1 << 0,
+		  ccBits: [10, 12, 14]
+		};
+
+		/**
+		 * Alphanumeric mode encodes data from a set of 45 characters,
+		 * i.e. 10 numeric digits (0 - 9),
+		 *      26 alphabetic characters (A - Z),
+		 *   and 9 symbols (SP, $, %, *, +, -, ., /, :).
+		 * Normally, two input characters are represented by 11 bits.
+		 *
+		 * @type {Object}
+		 */
+		exports$1.ALPHANUMERIC = {
+		  id: 'Alphanumeric',
+		  bit: 1 << 1,
+		  ccBits: [9, 11, 13]
+		};
+
+		/**
+		 * In byte mode, data is encoded at 8 bits per character.
+		 *
+		 * @type {Object}
+		 */
+		exports$1.BYTE = {
+		  id: 'Byte',
+		  bit: 1 << 2,
+		  ccBits: [8, 16, 16]
+		};
+
+		/**
+		 * The Kanji mode efficiently encodes Kanji characters in accordance with
+		 * the Shift JIS system based on JIS X 0208.
+		 * The Shift JIS values are shifted from the JIS X 0208 values.
+		 * JIS X 0208 gives details of the shift coded representation.
+		 * Each two-byte character value is compacted to a 13-bit binary codeword.
+		 *
+		 * @type {Object}
+		 */
+		exports$1.KANJI = {
+		  id: 'Kanji',
+		  bit: 1 << 3,
+		  ccBits: [8, 10, 12]
+		};
+
+		/**
+		 * Mixed mode will contain a sequences of data in a combination of any of
+		 * the modes described above
+		 *
+		 * @type {Object}
+		 */
+		exports$1.MIXED = {
+		  bit: -1
+		};
+
+		/**
+		 * Returns the number of bits needed to store the data length
+		 * according to QR Code specifications.
+		 *
+		 * @param  {Mode}   mode    Data mode
+		 * @param  {Number} version QR Code version
+		 * @return {Number}         Number of bits
+		 */
+		exports$1.getCharCountIndicator = function getCharCountIndicator (mode, version) {
+		  if (!mode.ccBits) throw new Error('Invalid mode: ' + mode)
+
+		  if (!VersionCheck.isValid(version)) {
+		    throw new Error('Invalid version: ' + version)
+		  }
+
+		  if (version >= 1 && version < 10) return mode.ccBits[0]
+		  else if (version < 27) return mode.ccBits[1]
+		  return mode.ccBits[2]
+		};
+
+		/**
+		 * Returns the most efficient mode to store the specified data
+		 *
+		 * @param  {String} dataStr Input data string
+		 * @return {Mode}           Best mode
+		 */
+		exports$1.getBestModeForData = function getBestModeForData (dataStr) {
+		  if (Regex.testNumeric(dataStr)) return exports$1.NUMERIC
+		  else if (Regex.testAlphanumeric(dataStr)) return exports$1.ALPHANUMERIC
+		  else if (Regex.testKanji(dataStr)) return exports$1.KANJI
+		  else return exports$1.BYTE
+		};
+
+		/**
+		 * Return mode name as string
+		 *
+		 * @param {Mode} mode Mode object
+		 * @returns {String}  Mode name
+		 */
+		exports$1.toString = function toString (mode) {
+		  if (mode && mode.id) return mode.id
+		  throw new Error('Invalid mode')
+		};
+
+		/**
+		 * Check if input param is a valid mode object
+		 *
+		 * @param   {Mode}    mode Mode object
+		 * @returns {Boolean} True if valid mode, false otherwise
+		 */
+		exports$1.isValid = function isValid (mode) {
+		  return mode && mode.bit && mode.ccBits
+		};
+
+		/**
+		 * Get mode object from its name
+		 *
+		 * @param   {String} string Mode name
+		 * @returns {Mode}          Mode object
+		 */
+		function fromString (string) {
+		  if (typeof string !== 'string') {
+		    throw new Error('Param is not a string')
+		  }
+
+		  const lcStr = string.toLowerCase();
+
+		  switch (lcStr) {
+		    case 'numeric':
+		      return exports$1.NUMERIC
+		    case 'alphanumeric':
+		      return exports$1.ALPHANUMERIC
+		    case 'kanji':
+		      return exports$1.KANJI
+		    case 'byte':
+		      return exports$1.BYTE
+		    default:
+		      throw new Error('Unknown mode: ' + string)
+		  }
+		}
+
+		/**
+		 * Returns mode from a value.
+		 * If value is not a valid mode, returns defaultValue
+		 *
+		 * @param  {Mode|String} value        Encoding mode
+		 * @param  {Mode}        defaultValue Fallback value
+		 * @return {Mode}                     Encoding mode
+		 */
+		exports$1.from = function from (value, defaultValue) {
+		  if (exports$1.isValid(value)) {
+		    return value
+		  }
+
+		  try {
+		    return fromString(value)
+		  } catch (e) {
+		    return defaultValue
+		  }
+		}; 
+	} (mode));
+	return mode;
+}
+
+var hasRequiredVersion;
+
+function requireVersion () {
+	if (hasRequiredVersion) return version;
+	hasRequiredVersion = 1;
+	(function (exports$1) {
+		const Utils = requireUtils$1();
+		const ECCode = requireErrorCorrectionCode();
+		const ECLevel = requireErrorCorrectionLevel();
+		const Mode = requireMode();
+		const VersionCheck = requireVersionCheck();
+
+		// Generator polynomial used to encode version information
+		const G18 = (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0);
+		const G18_BCH = Utils.getBCHDigit(G18);
+
+		function getBestVersionForDataLength (mode, length, errorCorrectionLevel) {
+		  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+		    if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel, mode)) {
+		      return currentVersion
+		    }
+		  }
+
+		  return undefined
+		}
+
+		function getReservedBitsCount (mode, version) {
+		  // Character count indicator + mode indicator bits
+		  return Mode.getCharCountIndicator(mode, version) + 4
+		}
+
+		function getTotalBitsFromDataArray (segments, version) {
+		  let totalBits = 0;
+
+		  segments.forEach(function (data) {
+		    const reservedBits = getReservedBitsCount(data.mode, version);
+		    totalBits += reservedBits + data.getBitsLength();
+		  });
+
+		  return totalBits
+		}
+
+		function getBestVersionForMixedData (segments, errorCorrectionLevel) {
+		  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+		    const length = getTotalBitsFromDataArray(segments, currentVersion);
+		    if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) {
+		      return currentVersion
+		    }
+		  }
+
+		  return undefined
+		}
+
+		/**
+		 * Returns version number from a value.
+		 * If value is not a valid version, returns defaultValue
+		 *
+		 * @param  {Number|String} value        QR Code version
+		 * @param  {Number}        defaultValue Fallback value
+		 * @return {Number}                     QR Code version number
+		 */
+		exports$1.from = function from (value, defaultValue) {
+		  if (VersionCheck.isValid(value)) {
+		    return parseInt(value, 10)
+		  }
+
+		  return defaultValue
+		};
+
+		/**
+		 * Returns how much data can be stored with the specified QR code version
+		 * and error correction level
+		 *
+		 * @param  {Number} version              QR Code version (1-40)
+		 * @param  {Number} errorCorrectionLevel Error correction level
+		 * @param  {Mode}   mode                 Data mode
+		 * @return {Number}                      Quantity of storable data
+		 */
+		exports$1.getCapacity = function getCapacity (version, errorCorrectionLevel, mode) {
+		  if (!VersionCheck.isValid(version)) {
+		    throw new Error('Invalid QR Code version')
+		  }
+
+		  // Use Byte mode as default
+		  if (typeof mode === 'undefined') mode = Mode.BYTE;
+
+		  // Total codewords for this QR code version (Data + Error correction)
+		  const totalCodewords = Utils.getSymbolTotalCodewords(version);
+
+		  // Total number of error correction codewords
+		  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+
+		  // Total number of data codewords
+		  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+
+		  if (mode === Mode.MIXED) return dataTotalCodewordsBits
+
+		  const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode, version);
+
+		  // Return max number of storable codewords
+		  switch (mode) {
+		    case Mode.NUMERIC:
+		      return Math.floor((usableBits / 10) * 3)
+
+		    case Mode.ALPHANUMERIC:
+		      return Math.floor((usableBits / 11) * 2)
+
+		    case Mode.KANJI:
+		      return Math.floor(usableBits / 13)
+
+		    case Mode.BYTE:
+		    default:
+		      return Math.floor(usableBits / 8)
+		  }
+		};
+
+		/**
+		 * Returns the minimum version needed to contain the amount of data
+		 *
+		 * @param  {Segment} data                    Segment of data
+		 * @param  {Number} [errorCorrectionLevel=H] Error correction level
+		 * @param  {Mode} mode                       Data mode
+		 * @return {Number}                          QR Code version
+		 */
+		exports$1.getBestVersionForData = function getBestVersionForData (data, errorCorrectionLevel) {
+		  let seg;
+
+		  const ecl = ECLevel.from(errorCorrectionLevel, ECLevel.M);
+
+		  if (Array.isArray(data)) {
+		    if (data.length > 1) {
+		      return getBestVersionForMixedData(data, ecl)
+		    }
+
+		    if (data.length === 0) {
+		      return 1
+		    }
+
+		    seg = data[0];
+		  } else {
+		    seg = data;
+		  }
+
+		  return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl)
+		};
+
+		/**
+		 * Returns version information with relative error correction bits
+		 *
+		 * The version information is included in QR Code symbols of version 7 or larger.
+		 * It consists of an 18-bit sequence containing 6 data bits,
+		 * with 12 error correction bits calculated using the (18, 6) Golay code.
+		 *
+		 * @param  {Number} version QR Code version
+		 * @return {Number}         Encoded version info bits
+		 */
+		exports$1.getEncodedBits = function getEncodedBits (version) {
+		  if (!VersionCheck.isValid(version) || version < 7) {
+		    throw new Error('Invalid QR Code version')
+		  }
+
+		  let d = version << 12;
+
+		  while (Utils.getBCHDigit(d) - G18_BCH >= 0) {
+		    d ^= (G18 << (Utils.getBCHDigit(d) - G18_BCH));
+		  }
+
+		  return (version << 12) | d
+		}; 
+	} (version));
+	return version;
+}
+
+var formatInfo = {};
+
+var hasRequiredFormatInfo;
+
+function requireFormatInfo () {
+	if (hasRequiredFormatInfo) return formatInfo;
+	hasRequiredFormatInfo = 1;
+	const Utils = requireUtils$1();
+
+	const G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0);
+	const G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1);
+	const G15_BCH = Utils.getBCHDigit(G15);
+
+	/**
+	 * Returns format information with relative error correction bits
+	 *
+	 * The format information is a 15-bit sequence containing 5 data bits,
+	 * with 10 error correction bits calculated using the (15, 5) BCH code.
+	 *
+	 * @param  {Number} errorCorrectionLevel Error correction level
+	 * @param  {Number} mask                 Mask pattern
+	 * @return {Number}                      Encoded format information bits
+	 */
+	formatInfo.getEncodedBits = function getEncodedBits (errorCorrectionLevel, mask) {
+	  const data = ((errorCorrectionLevel.bit << 3) | mask);
+	  let d = data << 10;
+
+	  while (Utils.getBCHDigit(d) - G15_BCH >= 0) {
+	    d ^= (G15 << (Utils.getBCHDigit(d) - G15_BCH));
+	  }
+
+	  // xor final data with mask pattern in order to ensure that
+	  // no combination of Error Correction Level and data mask pattern
+	  // will result in an all-zero data string
+	  return ((data << 10) | d) ^ G15_MASK
+	};
+	return formatInfo;
+}
+
+var segments = {};
+
+var numericData;
+var hasRequiredNumericData;
+
+function requireNumericData () {
+	if (hasRequiredNumericData) return numericData;
+	hasRequiredNumericData = 1;
+	const Mode = requireMode();
+
+	function NumericData (data) {
+	  this.mode = Mode.NUMERIC;
+	  this.data = data.toString();
+	}
+
+	NumericData.getBitsLength = function getBitsLength (length) {
+	  return 10 * Math.floor(length / 3) + ((length % 3) ? ((length % 3) * 3 + 1) : 0)
+	};
+
+	NumericData.prototype.getLength = function getLength () {
+	  return this.data.length
+	};
+
+	NumericData.prototype.getBitsLength = function getBitsLength () {
+	  return NumericData.getBitsLength(this.data.length)
+	};
+
+	NumericData.prototype.write = function write (bitBuffer) {
+	  let i, group, value;
+
+	  // The input data string is divided into groups of three digits,
+	  // and each group is converted to its 10-bit binary equivalent.
+	  for (i = 0; i + 3 <= this.data.length; i += 3) {
+	    group = this.data.substr(i, 3);
+	    value = parseInt(group, 10);
+
+	    bitBuffer.put(value, 10);
+	  }
+
+	  // If the number of input digits is not an exact multiple of three,
+	  // the final one or two digits are converted to 4 or 7 bits respectively.
+	  const remainingNum = this.data.length - i;
+	  if (remainingNum > 0) {
+	    group = this.data.substr(i);
+	    value = parseInt(group, 10);
+
+	    bitBuffer.put(value, remainingNum * 3 + 1);
+	  }
+	};
+
+	numericData = NumericData;
+	return numericData;
+}
+
+var alphanumericData;
+var hasRequiredAlphanumericData;
+
+function requireAlphanumericData () {
+	if (hasRequiredAlphanumericData) return alphanumericData;
+	hasRequiredAlphanumericData = 1;
+	const Mode = requireMode();
+
+	/**
+	 * Array of characters available in alphanumeric mode
+	 *
+	 * As per QR Code specification, to each character
+	 * is assigned a value from 0 to 44 which in this case coincides
+	 * with the array index
+	 *
+	 * @type {Array}
+	 */
+	const ALPHA_NUM_CHARS = [
+	  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+	  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+	  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	  ' ', '$', '%', '*', '+', '-', '.', '/', ':'
+	];
+
+	function AlphanumericData (data) {
+	  this.mode = Mode.ALPHANUMERIC;
+	  this.data = data;
+	}
+
+	AlphanumericData.getBitsLength = function getBitsLength (length) {
+	  return 11 * Math.floor(length / 2) + 6 * (length % 2)
+	};
+
+	AlphanumericData.prototype.getLength = function getLength () {
+	  return this.data.length
+	};
+
+	AlphanumericData.prototype.getBitsLength = function getBitsLength () {
+	  return AlphanumericData.getBitsLength(this.data.length)
+	};
+
+	AlphanumericData.prototype.write = function write (bitBuffer) {
+	  let i;
+
+	  // Input data characters are divided into groups of two characters
+	  // and encoded as 11-bit binary codes.
+	  for (i = 0; i + 2 <= this.data.length; i += 2) {
+	    // The character value of the first character is multiplied by 45
+	    let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
+
+	    // The character value of the second digit is added to the product
+	    value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
+
+	    // The sum is then stored as 11-bit binary number
+	    bitBuffer.put(value, 11);
+	  }
+
+	  // If the number of input data characters is not a multiple of two,
+	  // the character value of the final character is encoded as a 6-bit binary number.
+	  if (this.data.length % 2) {
+	    bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+	  }
+	};
+
+	alphanumericData = AlphanumericData;
+	return alphanumericData;
+}
+
+var byteData;
+var hasRequiredByteData;
+
+function requireByteData () {
+	if (hasRequiredByteData) return byteData;
+	hasRequiredByteData = 1;
+	const Mode = requireMode();
+
+	function ByteData (data) {
+	  this.mode = Mode.BYTE;
+	  if (typeof (data) === 'string') {
+	    this.data = new TextEncoder().encode(data);
+	  } else {
+	    this.data = new Uint8Array(data);
+	  }
+	}
+
+	ByteData.getBitsLength = function getBitsLength (length) {
+	  return length * 8
+	};
+
+	ByteData.prototype.getLength = function getLength () {
+	  return this.data.length
+	};
+
+	ByteData.prototype.getBitsLength = function getBitsLength () {
+	  return ByteData.getBitsLength(this.data.length)
+	};
+
+	ByteData.prototype.write = function (bitBuffer) {
+	  for (let i = 0, l = this.data.length; i < l; i++) {
+	    bitBuffer.put(this.data[i], 8);
+	  }
+	};
+
+	byteData = ByteData;
+	return byteData;
+}
+
+var kanjiData;
+var hasRequiredKanjiData;
+
+function requireKanjiData () {
+	if (hasRequiredKanjiData) return kanjiData;
+	hasRequiredKanjiData = 1;
+	const Mode = requireMode();
+	const Utils = requireUtils$1();
+
+	function KanjiData (data) {
+	  this.mode = Mode.KANJI;
+	  this.data = data;
+	}
+
+	KanjiData.getBitsLength = function getBitsLength (length) {
+	  return length * 13
+	};
+
+	KanjiData.prototype.getLength = function getLength () {
+	  return this.data.length
+	};
+
+	KanjiData.prototype.getBitsLength = function getBitsLength () {
+	  return KanjiData.getBitsLength(this.data.length)
+	};
+
+	KanjiData.prototype.write = function (bitBuffer) {
+	  let i;
+
+	  // In the Shift JIS system, Kanji characters are represented by a two byte combination.
+	  // These byte values are shifted from the JIS X 0208 values.
+	  // JIS X 0208 gives details of the shift coded representation.
+	  for (i = 0; i < this.data.length; i++) {
+	    let value = Utils.toSJIS(this.data[i]);
+
+	    // For characters with Shift JIS values from 0x8140 to 0x9FFC:
+	    if (value >= 0x8140 && value <= 0x9FFC) {
+	      // Subtract 0x8140 from Shift JIS value
+	      value -= 0x8140;
+
+	    // For characters with Shift JIS values from 0xE040 to 0xEBBF
+	    } else if (value >= 0xE040 && value <= 0xEBBF) {
+	      // Subtract 0xC140 from Shift JIS value
+	      value -= 0xC140;
+	    } else {
+	      throw new Error(
+	        'Invalid SJIS character: ' + this.data[i] + '\n' +
+	        'Make sure your charset is UTF-8')
+	    }
+
+	    // Multiply most significant byte of result by 0xC0
+	    // and add least significant byte to product
+	    value = (((value >>> 8) & 0xff) * 0xC0) + (value & 0xff);
+
+	    // Convert result to a 13-bit binary string
+	    bitBuffer.put(value, 13);
+	  }
+	};
+
+	kanjiData = KanjiData;
+	return kanjiData;
+}
+
+var dijkstra = {exports: {}};
+
+var hasRequiredDijkstra;
+
+function requireDijkstra () {
+	if (hasRequiredDijkstra) return dijkstra.exports;
+	hasRequiredDijkstra = 1;
+	(function (module) {
+
+		/******************************************************************************
+		 * Created 2008-08-19.
+		 *
+		 * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.
+		 *
+		 * Copyright (C) 2008
+		 *   Wyatt Baldwin <self@wyattbaldwin.com>
+		 *   All rights reserved
+		 *
+		 * Licensed under the MIT license.
+		 *
+		 *   http://www.opensource.org/licenses/mit-license.php
+		 *
+		 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+		 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+		 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+		 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+		 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+		 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+		 * THE SOFTWARE.
+		 *****************************************************************************/
+		var dijkstra = {
+		  single_source_shortest_paths: function(graph, s, d) {
+		    // Predecessor map for each node that has been encountered.
+		    // node ID => predecessor node ID
+		    var predecessors = {};
+
+		    // Costs of shortest paths from s to all nodes encountered.
+		    // node ID => cost
+		    var costs = {};
+		    costs[s] = 0;
+
+		    // Costs of shortest paths from s to all nodes encountered; differs from
+		    // `costs` in that it provides easy access to the node that currently has
+		    // the known shortest path from s.
+		    // XXX: Do we actually need both `costs` and `open`?
+		    var open = dijkstra.PriorityQueue.make();
+		    open.push(s, 0);
+
+		    var closest,
+		        u, v,
+		        cost_of_s_to_u,
+		        adjacent_nodes,
+		        cost_of_e,
+		        cost_of_s_to_u_plus_cost_of_e,
+		        cost_of_s_to_v,
+		        first_visit;
+		    while (!open.empty()) {
+		      // In the nodes remaining in graph that have a known cost from s,
+		      // find the node, u, that currently has the shortest path from s.
+		      closest = open.pop();
+		      u = closest.value;
+		      cost_of_s_to_u = closest.cost;
+
+		      // Get nodes adjacent to u...
+		      adjacent_nodes = graph[u] || {};
+
+		      // ...and explore the edges that connect u to those nodes, updating
+		      // the cost of the shortest paths to any or all of those nodes as
+		      // necessary. v is the node across the current edge from u.
+		      for (v in adjacent_nodes) {
+		        if (adjacent_nodes.hasOwnProperty(v)) {
+		          // Get the cost of the edge running from u to v.
+		          cost_of_e = adjacent_nodes[v];
+
+		          // Cost of s to u plus the cost of u to v across e--this is *a*
+		          // cost from s to v that may or may not be less than the current
+		          // known cost to v.
+		          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
+
+		          // If we haven't visited v yet OR if the current known cost from s to
+		          // v is greater than the new cost we just found (cost of s to u plus
+		          // cost of u to v across e), update v's cost in the cost list and
+		          // update v's predecessor in the predecessor list (it's now u).
+		          cost_of_s_to_v = costs[v];
+		          first_visit = (typeof costs[v] === 'undefined');
+		          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
+		            costs[v] = cost_of_s_to_u_plus_cost_of_e;
+		            open.push(v, cost_of_s_to_u_plus_cost_of_e);
+		            predecessors[v] = u;
+		          }
+		        }
+		      }
+		    }
+
+		    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {
+		      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');
+		      throw new Error(msg);
+		    }
+
+		    return predecessors;
+		  },
+
+		  extract_shortest_path_from_predecessor_list: function(predecessors, d) {
+		    var nodes = [];
+		    var u = d;
+		    while (u) {
+		      nodes.push(u);
+		      predecessors[u];
+		      u = predecessors[u];
+		    }
+		    nodes.reverse();
+		    return nodes;
+		  },
+
+		  find_path: function(graph, s, d) {
+		    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);
+		    return dijkstra.extract_shortest_path_from_predecessor_list(
+		      predecessors, d);
+		  },
+
+		  /**
+		   * A very naive priority queue implementation.
+		   */
+		  PriorityQueue: {
+		    make: function (opts) {
+		      var T = dijkstra.PriorityQueue,
+		          t = {},
+		          key;
+		      opts = opts || {};
+		      for (key in T) {
+		        if (T.hasOwnProperty(key)) {
+		          t[key] = T[key];
+		        }
+		      }
+		      t.queue = [];
+		      t.sorter = opts.sorter || T.default_sorter;
+		      return t;
+		    },
+
+		    default_sorter: function (a, b) {
+		      return a.cost - b.cost;
+		    },
+
+		    /**
+		     * Add a new item to the queue and ensure the highest priority element
+		     * is at the front of the queue.
+		     */
+		    push: function (value, cost) {
+		      var item = {value: value, cost: cost};
+		      this.queue.push(item);
+		      this.queue.sort(this.sorter);
+		    },
+
+		    /**
+		     * Return the highest priority element in the queue.
+		     */
+		    pop: function () {
+		      return this.queue.shift();
+		    },
+
+		    empty: function () {
+		      return this.queue.length === 0;
+		    }
+		  }
+		};
+
+
+		// node.js module exports
+		{
+		  module.exports = dijkstra;
+		} 
+	} (dijkstra));
+	return dijkstra.exports;
+}
+
+var hasRequiredSegments;
+
+function requireSegments () {
+	if (hasRequiredSegments) return segments;
+	hasRequiredSegments = 1;
+	(function (exports$1) {
+		const Mode = requireMode();
+		const NumericData = requireNumericData();
+		const AlphanumericData = requireAlphanumericData();
+		const ByteData = requireByteData();
+		const KanjiData = requireKanjiData();
+		const Regex = requireRegex();
+		const Utils = requireUtils$1();
+		const dijkstra = requireDijkstra();
+
+		/**
+		 * Returns UTF8 byte length
+		 *
+		 * @param  {String} str Input string
+		 * @return {Number}     Number of byte
+		 */
+		function getStringByteLength (str) {
+		  return unescape(encodeURIComponent(str)).length
+		}
+
+		/**
+		 * Get a list of segments of the specified mode
+		 * from a string
+		 *
+		 * @param  {Mode}   mode Segment mode
+		 * @param  {String} str  String to process
+		 * @return {Array}       Array of object with segments data
+		 */
+		function getSegments (regex, mode, str) {
+		  const segments = [];
+		  let result;
+
+		  while ((result = regex.exec(str)) !== null) {
+		    segments.push({
+		      data: result[0],
+		      index: result.index,
+		      mode: mode,
+		      length: result[0].length
+		    });
+		  }
+
+		  return segments
+		}
+
+		/**
+		 * Extracts a series of segments with the appropriate
+		 * modes from a string
+		 *
+		 * @param  {String} dataStr Input string
+		 * @return {Array}          Array of object with segments data
+		 */
+		function getSegmentsFromString (dataStr) {
+		  const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
+		  const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
+		  let byteSegs;
+		  let kanjiSegs;
+
+		  if (Utils.isKanjiModeEnabled()) {
+		    byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
+		    kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
+		  } else {
+		    byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr);
+		    kanjiSegs = [];
+		  }
+
+		  const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
+
+		  return segs
+		    .sort(function (s1, s2) {
+		      return s1.index - s2.index
+		    })
+		    .map(function (obj) {
+		      return {
+		        data: obj.data,
+		        mode: obj.mode,
+		        length: obj.length
+		      }
+		    })
+		}
+
+		/**
+		 * Returns how many bits are needed to encode a string of
+		 * specified length with the specified mode
+		 *
+		 * @param  {Number} length String length
+		 * @param  {Mode} mode     Segment mode
+		 * @return {Number}        Bit length
+		 */
+		function getSegmentBitsLength (length, mode) {
+		  switch (mode) {
+		    case Mode.NUMERIC:
+		      return NumericData.getBitsLength(length)
+		    case Mode.ALPHANUMERIC:
+		      return AlphanumericData.getBitsLength(length)
+		    case Mode.KANJI:
+		      return KanjiData.getBitsLength(length)
+		    case Mode.BYTE:
+		      return ByteData.getBitsLength(length)
+		  }
+		}
+
+		/**
+		 * Merges adjacent segments which have the same mode
+		 *
+		 * @param  {Array} segs Array of object with segments data
+		 * @return {Array}      Array of object with segments data
+		 */
+		function mergeSegments (segs) {
+		  return segs.reduce(function (acc, curr) {
+		    const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+		    if (prevSeg && prevSeg.mode === curr.mode) {
+		      acc[acc.length - 1].data += curr.data;
+		      return acc
+		    }
+
+		    acc.push(curr);
+		    return acc
+		  }, [])
+		}
+
+		/**
+		 * Generates a list of all possible nodes combination which
+		 * will be used to build a segments graph.
+		 *
+		 * Nodes are divided by groups. Each group will contain a list of all the modes
+		 * in which is possible to encode the given text.
+		 *
+		 * For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.
+		 * The group for '12345' will contain then 3 objects, one for each
+		 * possible encoding mode.
+		 *
+		 * Each node represents a possible segment.
+		 *
+		 * @param  {Array} segs Array of object with segments data
+		 * @return {Array}      Array of object with segments data
+		 */
+		function buildNodes (segs) {
+		  const nodes = [];
+		  for (let i = 0; i < segs.length; i++) {
+		    const seg = segs[i];
+
+		    switch (seg.mode) {
+		      case Mode.NUMERIC:
+		        nodes.push([seg,
+		          { data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },
+		          { data: seg.data, mode: Mode.BYTE, length: seg.length }
+		        ]);
+		        break
+		      case Mode.ALPHANUMERIC:
+		        nodes.push([seg,
+		          { data: seg.data, mode: Mode.BYTE, length: seg.length }
+		        ]);
+		        break
+		      case Mode.KANJI:
+		        nodes.push([seg,
+		          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
+		        ]);
+		        break
+		      case Mode.BYTE:
+		        nodes.push([
+		          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
+		        ]);
+		    }
+		  }
+
+		  return nodes
+		}
+
+		/**
+		 * Builds a graph from a list of nodes.
+		 * All segments in each node group will be connected with all the segments of
+		 * the next group and so on.
+		 *
+		 * At each connection will be assigned a weight depending on the
+		 * segment's byte length.
+		 *
+		 * @param  {Array} nodes    Array of object with segments data
+		 * @param  {Number} version QR Code version
+		 * @return {Object}         Graph of all possible segments
+		 */
+		function buildGraph (nodes, version) {
+		  const table = {};
+		  const graph = { start: {} };
+		  let prevNodeIds = ['start'];
+
+		  for (let i = 0; i < nodes.length; i++) {
+		    const nodeGroup = nodes[i];
+		    const currentNodeIds = [];
+
+		    for (let j = 0; j < nodeGroup.length; j++) {
+		      const node = nodeGroup[j];
+		      const key = '' + i + j;
+
+		      currentNodeIds.push(key);
+		      table[key] = { node: node, lastCount: 0 };
+		      graph[key] = {};
+
+		      for (let n = 0; n < prevNodeIds.length; n++) {
+		        const prevNodeId = prevNodeIds[n];
+
+		        if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
+		          graph[prevNodeId][key] =
+		            getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -
+		            getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
+
+		          table[prevNodeId].lastCount += node.length;
+		        } else {
+		          if (table[prevNodeId]) table[prevNodeId].lastCount = node.length;
+
+		          graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +
+		            4 + Mode.getCharCountIndicator(node.mode, version); // switch cost
+		        }
+		      }
+		    }
+
+		    prevNodeIds = currentNodeIds;
+		  }
+
+		  for (let n = 0; n < prevNodeIds.length; n++) {
+		    graph[prevNodeIds[n]].end = 0;
+		  }
+
+		  return { map: graph, table: table }
+		}
+
+		/**
+		 * Builds a segment from a specified data and mode.
+		 * If a mode is not specified, the more suitable will be used.
+		 *
+		 * @param  {String} data             Input data
+		 * @param  {Mode | String} modesHint Data mode
+		 * @return {Segment}                 Segment
+		 */
+		function buildSingleSegment (data, modesHint) {
+		  let mode;
+		  const bestMode = Mode.getBestModeForData(data);
+
+		  mode = Mode.from(modesHint, bestMode);
+
+		  // Make sure data can be encoded
+		  if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {
+		    throw new Error('"' + data + '"' +
+		      ' cannot be encoded with mode ' + Mode.toString(mode) +
+		      '.\n Suggested mode is: ' + Mode.toString(bestMode))
+		  }
+
+		  // Use Mode.BYTE if Kanji support is disabled
+		  if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
+		    mode = Mode.BYTE;
+		  }
+
+		  switch (mode) {
+		    case Mode.NUMERIC:
+		      return new NumericData(data)
+
+		    case Mode.ALPHANUMERIC:
+		      return new AlphanumericData(data)
+
+		    case Mode.KANJI:
+		      return new KanjiData(data)
+
+		    case Mode.BYTE:
+		      return new ByteData(data)
+		  }
+		}
+
+		/**
+		 * Builds a list of segments from an array.
+		 * Array can contain Strings or Objects with segment's info.
+		 *
+		 * For each item which is a string, will be generated a segment with the given
+		 * string and the more appropriate encoding mode.
+		 *
+		 * For each item which is an object, will be generated a segment with the given
+		 * data and mode.
+		 * Objects must contain at least the property "data".
+		 * If property "mode" is not present, the more suitable mode will be used.
+		 *
+		 * @param  {Array} array Array of objects with segments data
+		 * @return {Array}       Array of Segments
+		 */
+		exports$1.fromArray = function fromArray (array) {
+		  return array.reduce(function (acc, seg) {
+		    if (typeof seg === 'string') {
+		      acc.push(buildSingleSegment(seg, null));
+		    } else if (seg.data) {
+		      acc.push(buildSingleSegment(seg.data, seg.mode));
+		    }
+
+		    return acc
+		  }, [])
+		};
+
+		/**
+		 * Builds an optimized sequence of segments from a string,
+		 * which will produce the shortest possible bitstream.
+		 *
+		 * @param  {String} data    Input string
+		 * @param  {Number} version QR Code version
+		 * @return {Array}          Array of segments
+		 */
+		exports$1.fromString = function fromString (data, version) {
+		  const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
+
+		  const nodes = buildNodes(segs);
+		  const graph = buildGraph(nodes, version);
+		  const path = dijkstra.find_path(graph.map, 'start', 'end');
+
+		  const optimizedSegs = [];
+		  for (let i = 1; i < path.length - 1; i++) {
+		    optimizedSegs.push(graph.table[path[i]].node);
+		  }
+
+		  return exports$1.fromArray(mergeSegments(optimizedSegs))
+		};
+
+		/**
+		 * Splits a string in various segments with the modes which
+		 * best represent their content.
+		 * The produced segments are far from being optimized.
+		 * The output of this function is only used to estimate a QR Code version
+		 * which may contain the data.
+		 *
+		 * @param  {string} data Input string
+		 * @return {Array}       Array of segments
+		 */
+		exports$1.rawSplit = function rawSplit (data) {
+		  return exports$1.fromArray(
+		    getSegmentsFromString(data, Utils.isKanjiModeEnabled())
+		  )
+		}; 
+	} (segments));
+	return segments;
+}
+
+var hasRequiredQrcode;
+
+function requireQrcode () {
+	if (hasRequiredQrcode) return qrcode;
+	hasRequiredQrcode = 1;
+	const Utils = requireUtils$1();
+	const ECLevel = requireErrorCorrectionLevel();
+	const BitBuffer = requireBitBuffer();
+	const BitMatrix = requireBitMatrix();
+	const AlignmentPattern = requireAlignmentPattern();
+	const FinderPattern = requireFinderPattern();
+	const MaskPattern = requireMaskPattern();
+	const ECCode = requireErrorCorrectionCode();
+	const ReedSolomonEncoder = requireReedSolomonEncoder();
+	const Version = requireVersion();
+	const FormatInfo = requireFormatInfo();
+	const Mode = requireMode();
+	const Segments = requireSegments();
+
+	/**
+	 * QRCode for JavaScript
+	 *
+	 * modified by Ryan Day for nodejs support
+	 * Copyright (c) 2011 Ryan Day
+	 *
+	 * Licensed under the MIT license:
+	 *   http://www.opensource.org/licenses/mit-license.php
+	 *
+	//---------------------------------------------------------------------
+	// QRCode for JavaScript
+	//
+	// Copyright (c) 2009 Kazuhiko Arase
+	//
+	// URL: http://www.d-project.com/
+	//
+	// Licensed under the MIT license:
+	//   http://www.opensource.org/licenses/mit-license.php
+	//
+	// The word "QR Code" is registered trademark of
+	// DENSO WAVE INCORPORATED
+	//   http://www.denso-wave.com/qrcode/faqpatent-e.html
+	//
+	//---------------------------------------------------------------------
+	*/
+
+	/**
+	 * Add finder patterns bits to matrix
+	 *
+	 * @param  {BitMatrix} matrix  Modules matrix
+	 * @param  {Number}    version QR Code version
+	 */
+	function setupFinderPattern (matrix, version) {
+	  const size = matrix.size;
+	  const pos = FinderPattern.getPositions(version);
+
+	  for (let i = 0; i < pos.length; i++) {
+	    const row = pos[i][0];
+	    const col = pos[i][1];
+
+	    for (let r = -1; r <= 7; r++) {
+	      if (row + r <= -1 || size <= row + r) continue
+
+	      for (let c = -1; c <= 7; c++) {
+	        if (col + c <= -1 || size <= col + c) continue
+
+	        if ((r >= 0 && r <= 6 && (c === 0 || c === 6)) ||
+	          (c >= 0 && c <= 6 && (r === 0 || r === 6)) ||
+	          (r >= 2 && r <= 4 && c >= 2 && c <= 4)) {
+	          matrix.set(row + r, col + c, true, true);
+	        } else {
+	          matrix.set(row + r, col + c, false, true);
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Add timing pattern bits to matrix
+	 *
+	 * Note: this function must be called before {@link setupAlignmentPattern}
+	 *
+	 * @param  {BitMatrix} matrix Modules matrix
+	 */
+	function setupTimingPattern (matrix) {
+	  const size = matrix.size;
+
+	  for (let r = 8; r < size - 8; r++) {
+	    const value = r % 2 === 0;
+	    matrix.set(r, 6, value, true);
+	    matrix.set(6, r, value, true);
+	  }
+	}
+
+	/**
+	 * Add alignment patterns bits to matrix
+	 *
+	 * Note: this function must be called after {@link setupTimingPattern}
+	 *
+	 * @param  {BitMatrix} matrix  Modules matrix
+	 * @param  {Number}    version QR Code version
+	 */
+	function setupAlignmentPattern (matrix, version) {
+	  const pos = AlignmentPattern.getPositions(version);
+
+	  for (let i = 0; i < pos.length; i++) {
+	    const row = pos[i][0];
+	    const col = pos[i][1];
+
+	    for (let r = -2; r <= 2; r++) {
+	      for (let c = -2; c <= 2; c++) {
+	        if (r === -2 || r === 2 || c === -2 || c === 2 ||
+	          (r === 0 && c === 0)) {
+	          matrix.set(row + r, col + c, true, true);
+	        } else {
+	          matrix.set(row + r, col + c, false, true);
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Add version info bits to matrix
+	 *
+	 * @param  {BitMatrix} matrix  Modules matrix
+	 * @param  {Number}    version QR Code version
+	 */
+	function setupVersionInfo (matrix, version) {
+	  const size = matrix.size;
+	  const bits = Version.getEncodedBits(version);
+	  let row, col, mod;
+
+	  for (let i = 0; i < 18; i++) {
+	    row = Math.floor(i / 3);
+	    col = i % 3 + size - 8 - 3;
+	    mod = ((bits >> i) & 1) === 1;
+
+	    matrix.set(row, col, mod, true);
+	    matrix.set(col, row, mod, true);
+	  }
+	}
+
+	/**
+	 * Add format info bits to matrix
+	 *
+	 * @param  {BitMatrix} matrix               Modules matrix
+	 * @param  {ErrorCorrectionLevel}    errorCorrectionLevel Error correction level
+	 * @param  {Number}    maskPattern          Mask pattern reference value
+	 */
+	function setupFormatInfo (matrix, errorCorrectionLevel, maskPattern) {
+	  const size = matrix.size;
+	  const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);
+	  let i, mod;
+
+	  for (i = 0; i < 15; i++) {
+	    mod = ((bits >> i) & 1) === 1;
+
+	    // vertical
+	    if (i < 6) {
+	      matrix.set(i, 8, mod, true);
+	    } else if (i < 8) {
+	      matrix.set(i + 1, 8, mod, true);
+	    } else {
+	      matrix.set(size - 15 + i, 8, mod, true);
+	    }
+
+	    // horizontal
+	    if (i < 8) {
+	      matrix.set(8, size - i - 1, mod, true);
+	    } else if (i < 9) {
+	      matrix.set(8, 15 - i - 1 + 1, mod, true);
+	    } else {
+	      matrix.set(8, 15 - i - 1, mod, true);
+	    }
+	  }
+
+	  // fixed module
+	  matrix.set(size - 8, 8, 1, true);
+	}
+
+	/**
+	 * Add encoded data bits to matrix
+	 *
+	 * @param  {BitMatrix}  matrix Modules matrix
+	 * @param  {Uint8Array} data   Data codewords
+	 */
+	function setupData (matrix, data) {
+	  const size = matrix.size;
+	  let inc = -1;
+	  let row = size - 1;
+	  let bitIndex = 7;
+	  let byteIndex = 0;
+
+	  for (let col = size - 1; col > 0; col -= 2) {
+	    if (col === 6) col--;
+
+	    while (true) {
+	      for (let c = 0; c < 2; c++) {
+	        if (!matrix.isReserved(row, col - c)) {
+	          let dark = false;
+
+	          if (byteIndex < data.length) {
+	            dark = (((data[byteIndex] >>> bitIndex) & 1) === 1);
+	          }
+
+	          matrix.set(row, col - c, dark);
+	          bitIndex--;
+
+	          if (bitIndex === -1) {
+	            byteIndex++;
+	            bitIndex = 7;
+	          }
+	        }
+	      }
+
+	      row += inc;
+
+	      if (row < 0 || size <= row) {
+	        row -= inc;
+	        inc = -inc;
+	        break
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Create encoded codewords from data input
+	 *
+	 * @param  {Number}   version              QR Code version
+	 * @param  {ErrorCorrectionLevel}   errorCorrectionLevel Error correction level
+	 * @param  {ByteData} data                 Data input
+	 * @return {Uint8Array}                    Buffer containing encoded codewords
+	 */
+	function createData (version, errorCorrectionLevel, segments) {
+	  // Prepare data buffer
+	  const buffer = new BitBuffer();
+
+	  segments.forEach(function (data) {
+	    // prefix data with mode indicator (4 bits)
+	    buffer.put(data.mode.bit, 4);
+
+	    // Prefix data with character count indicator.
+	    // The character count indicator is a string of bits that represents the
+	    // number of characters that are being encoded.
+	    // The character count indicator must be placed after the mode indicator
+	    // and must be a certain number of bits long, depending on the QR version
+	    // and data mode
+	    // @see {@link Mode.getCharCountIndicator}.
+	    buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version));
+
+	    // add binary data sequence to buffer
+	    data.write(buffer);
+	  });
+
+	  // Calculate required number of bits
+	  const totalCodewords = Utils.getSymbolTotalCodewords(version);
+	  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+	  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+
+	  // Add a terminator.
+	  // If the bit string is shorter than the total number of required bits,
+	  // a terminator of up to four 0s must be added to the right side of the string.
+	  // If the bit string is more than four bits shorter than the required number of bits,
+	  // add four 0s to the end.
+	  if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
+	    buffer.put(0, 4);
+	  }
+
+	  // If the bit string is fewer than four bits shorter, add only the number of 0s that
+	  // are needed to reach the required number of bits.
+
+	  // After adding the terminator, if the number of bits in the string is not a multiple of 8,
+	  // pad the string on the right with 0s to make the string's length a multiple of 8.
+	  while (buffer.getLengthInBits() % 8 !== 0) {
+	    buffer.putBit(0);
+	  }
+
+	  // Add pad bytes if the string is still shorter than the total number of required bits.
+	  // Extend the buffer to fill the data capacity of the symbol corresponding to
+	  // the Version and Error Correction Level by adding the Pad Codewords 11101100 (0xEC)
+	  // and 00010001 (0x11) alternately.
+	  const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
+	  for (let i = 0; i < remainingByte; i++) {
+	    buffer.put(i % 2 ? 0x11 : 0xEC, 8);
+	  }
+
+	  return createCodewords(buffer, version, errorCorrectionLevel)
+	}
+
+	/**
+	 * Encode input data with Reed-Solomon and return codewords with
+	 * relative error correction bits
+	 *
+	 * @param  {BitBuffer} bitBuffer            Data to encode
+	 * @param  {Number}    version              QR Code version
+	 * @param  {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
+	 * @return {Uint8Array}                     Buffer containing encoded codewords
+	 */
+	function createCodewords (bitBuffer, version, errorCorrectionLevel) {
+	  // Total codewords for this QR code version (Data + Error correction)
+	  const totalCodewords = Utils.getSymbolTotalCodewords(version);
+
+	  // Total number of error correction codewords
+	  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+
+	  // Total number of data codewords
+	  const dataTotalCodewords = totalCodewords - ecTotalCodewords;
+
+	  // Total number of blocks
+	  const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel);
+
+	  // Calculate how many blocks each group should contain
+	  const blocksInGroup2 = totalCodewords % ecTotalBlocks;
+	  const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
+
+	  const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
+
+	  const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
+	  const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
+
+	  // Number of EC codewords is the same for both groups
+	  const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
+
+	  // Initialize a Reed-Solomon encoder with a generator polynomial of degree ecCount
+	  const rs = new ReedSolomonEncoder(ecCount);
+
+	  let offset = 0;
+	  const dcData = new Array(ecTotalBlocks);
+	  const ecData = new Array(ecTotalBlocks);
+	  let maxDataSize = 0;
+	  const buffer = new Uint8Array(bitBuffer.buffer);
+
+	  // Divide the buffer into the required number of blocks
+	  for (let b = 0; b < ecTotalBlocks; b++) {
+	    const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
+
+	    // extract a block of data from buffer
+	    dcData[b] = buffer.slice(offset, offset + dataSize);
+
+	    // Calculate EC codewords for this data block
+	    ecData[b] = rs.encode(dcData[b]);
+
+	    offset += dataSize;
+	    maxDataSize = Math.max(maxDataSize, dataSize);
+	  }
+
+	  // Create final data
+	  // Interleave the data and error correction codewords from each block
+	  const data = new Uint8Array(totalCodewords);
+	  let index = 0;
+	  let i, r;
+
+	  // Add data codewords
+	  for (i = 0; i < maxDataSize; i++) {
+	    for (r = 0; r < ecTotalBlocks; r++) {
+	      if (i < dcData[r].length) {
+	        data[index++] = dcData[r][i];
+	      }
+	    }
+	  }
+
+	  // Apped EC codewords
+	  for (i = 0; i < ecCount; i++) {
+	    for (r = 0; r < ecTotalBlocks; r++) {
+	      data[index++] = ecData[r][i];
+	    }
+	  }
+
+	  return data
+	}
+
+	/**
+	 * Build QR Code symbol
+	 *
+	 * @param  {String} data                 Input string
+	 * @param  {Number} version              QR Code version
+	 * @param  {ErrorCorretionLevel} errorCorrectionLevel Error level
+	 * @param  {MaskPattern} maskPattern     Mask pattern
+	 * @return {Object}                      Object containing symbol data
+	 */
+	function createSymbol (data, version, errorCorrectionLevel, maskPattern) {
+	  let segments;
+
+	  if (Array.isArray(data)) {
+	    segments = Segments.fromArray(data);
+	  } else if (typeof data === 'string') {
+	    let estimatedVersion = version;
+
+	    if (!estimatedVersion) {
+	      const rawSegments = Segments.rawSplit(data);
+
+	      // Estimate best version that can contain raw splitted segments
+	      estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel);
+	    }
+
+	    // Build optimized segments
+	    // If estimated version is undefined, try with the highest version
+	    segments = Segments.fromString(data, estimatedVersion || 40);
+	  } else {
+	    throw new Error('Invalid data')
+	  }
+
+	  // Get the min version that can contain data
+	  const bestVersion = Version.getBestVersionForData(segments, errorCorrectionLevel);
+
+	  // If no version is found, data cannot be stored
+	  if (!bestVersion) {
+	    throw new Error('The amount of data is too big to be stored in a QR Code')
+	  }
+
+	  // If not specified, use min version as default
+	  if (!version) {
+	    version = bestVersion;
+
+	  // Check if the specified version can contain the data
+	  } else if (version < bestVersion) {
+	    throw new Error('\n' +
+	      'The chosen QR Code version cannot contain this amount of data.\n' +
+	      'Minimum version required to store current data is: ' + bestVersion + '.\n'
+	    )
+	  }
+
+	  const dataBits = createData(version, errorCorrectionLevel, segments);
+
+	  // Allocate matrix buffer
+	  const moduleCount = Utils.getSymbolSize(version);
+	  const modules = new BitMatrix(moduleCount);
+
+	  // Add function modules
+	  setupFinderPattern(modules, version);
+	  setupTimingPattern(modules);
+	  setupAlignmentPattern(modules, version);
+
+	  // Add temporary dummy bits for format info just to set them as reserved.
+	  // This is needed to prevent these bits from being masked by {@link MaskPattern.applyMask}
+	  // since the masking operation must be performed only on the encoding region.
+	  // These blocks will be replaced with correct values later in code.
+	  setupFormatInfo(modules, errorCorrectionLevel, 0);
+
+	  if (version >= 7) {
+	    setupVersionInfo(modules, version);
+	  }
+
+	  // Add data codewords
+	  setupData(modules, dataBits);
+
+	  if (isNaN(maskPattern)) {
+	    // Find best mask pattern
+	    maskPattern = MaskPattern.getBestMask(modules,
+	      setupFormatInfo.bind(null, modules, errorCorrectionLevel));
+	  }
+
+	  // Apply mask pattern
+	  MaskPattern.applyMask(maskPattern, modules);
+
+	  // Replace format info bits with correct values
+	  setupFormatInfo(modules, errorCorrectionLevel, maskPattern);
+
+	  return {
+	    modules: modules,
+	    version: version,
+	    errorCorrectionLevel: errorCorrectionLevel,
+	    maskPattern: maskPattern,
+	    segments: segments
+	  }
+	}
+
+	/**
+	 * QR Code
+	 *
+	 * @param {String | Array} data                 Input data
+	 * @param {Object} options                      Optional configurations
+	 * @param {Number} options.version              QR Code version
+	 * @param {String} options.errorCorrectionLevel Error correction level
+	 * @param {Function} options.toSJISFunc         Helper func to convert utf8 to sjis
+	 */
+	qrcode.create = function create (data, options) {
+	  if (typeof data === 'undefined' || data === '') {
+	    throw new Error('No input text')
+	  }
+
+	  let errorCorrectionLevel = ECLevel.M;
+	  let version;
+	  let mask;
+
+	  if (typeof options !== 'undefined') {
+	    // Use higher error correction level as default
+	    errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
+	    version = Version.from(options.version);
+	    mask = MaskPattern.from(options.maskPattern);
+
+	    if (options.toSJISFunc) {
+	      Utils.setToSJISFunction(options.toSJISFunc);
+	    }
+	  }
+
+	  return createSymbol(data, version, errorCorrectionLevel, mask)
+	};
+	return qrcode;
+}
+
+var canvas = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports$1) {
+		function hex2rgba (hex) {
+		  if (typeof hex === 'number') {
+		    hex = hex.toString();
+		  }
+
+		  if (typeof hex !== 'string') {
+		    throw new Error('Color should be defined as hex string')
+		  }
+
+		  let hexCode = hex.slice().replace('#', '').split('');
+		  if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
+		    throw new Error('Invalid hex color: ' + hex)
+		  }
+
+		  // Convert from short to long form (fff -> ffffff)
+		  if (hexCode.length === 3 || hexCode.length === 4) {
+		    hexCode = Array.prototype.concat.apply([], hexCode.map(function (c) {
+		      return [c, c]
+		    }));
+		  }
+
+		  // Add default alpha value
+		  if (hexCode.length === 6) hexCode.push('F', 'F');
+
+		  const hexValue = parseInt(hexCode.join(''), 16);
+
+		  return {
+		    r: (hexValue >> 24) & 255,
+		    g: (hexValue >> 16) & 255,
+		    b: (hexValue >> 8) & 255,
+		    a: hexValue & 255,
+		    hex: '#' + hexCode.slice(0, 6).join('')
+		  }
+		}
+
+		exports$1.getOptions = function getOptions (options) {
+		  if (!options) options = {};
+		  if (!options.color) options.color = {};
+
+		  const margin = typeof options.margin === 'undefined' ||
+		    options.margin === null ||
+		    options.margin < 0
+		    ? 4
+		    : options.margin;
+
+		  const width = options.width && options.width >= 21 ? options.width : undefined;
+		  const scale = options.scale || 4;
+
+		  return {
+		    width: width,
+		    scale: width ? 4 : scale,
+		    margin: margin,
+		    color: {
+		      dark: hex2rgba(options.color.dark || '#000000ff'),
+		      light: hex2rgba(options.color.light || '#ffffffff')
+		    },
+		    type: options.type,
+		    rendererOpts: options.rendererOpts || {}
+		  }
+		};
+
+		exports$1.getScale = function getScale (qrSize, opts) {
+		  return opts.width && opts.width >= qrSize + opts.margin * 2
+		    ? opts.width / (qrSize + opts.margin * 2)
+		    : opts.scale
+		};
+
+		exports$1.getImageWidth = function getImageWidth (qrSize, opts) {
+		  const scale = exports$1.getScale(qrSize, opts);
+		  return Math.floor((qrSize + opts.margin * 2) * scale)
+		};
+
+		exports$1.qrToImageData = function qrToImageData (imgData, qr, opts) {
+		  const size = qr.modules.size;
+		  const data = qr.modules.data;
+		  const scale = exports$1.getScale(size, opts);
+		  const symbolSize = Math.floor((size + opts.margin * 2) * scale);
+		  const scaledMargin = opts.margin * scale;
+		  const palette = [opts.color.light, opts.color.dark];
+
+		  for (let i = 0; i < symbolSize; i++) {
+		    for (let j = 0; j < symbolSize; j++) {
+		      let posDst = (i * symbolSize + j) * 4;
+		      let pxColor = opts.color.light;
+
+		      if (i >= scaledMargin && j >= scaledMargin &&
+		        i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {
+		        const iSrc = Math.floor((i - scaledMargin) / scale);
+		        const jSrc = Math.floor((j - scaledMargin) / scale);
+		        pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
+		      }
+
+		      imgData[posDst++] = pxColor.r;
+		      imgData[posDst++] = pxColor.g;
+		      imgData[posDst++] = pxColor.b;
+		      imgData[posDst] = pxColor.a;
+		    }
+		  }
+		}; 
+	} (utils));
+	return utils;
+}
+
+var hasRequiredCanvas;
+
+function requireCanvas () {
+	if (hasRequiredCanvas) return canvas;
+	hasRequiredCanvas = 1;
+	(function (exports$1) {
+		const Utils = requireUtils();
+
+		function clearCanvas (ctx, canvas, size) {
+		  ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+		  if (!canvas.style) canvas.style = {};
+		  canvas.height = size;
+		  canvas.width = size;
+		  canvas.style.height = size + 'px';
+		  canvas.style.width = size + 'px';
+		}
+
+		function getCanvasElement () {
+		  try {
+		    return document.createElement('canvas')
+		  } catch (e) {
+		    throw new Error('You need to specify a canvas element')
+		  }
+		}
+
+		exports$1.render = function render (qrData, canvas, options) {
+		  let opts = options;
+		  let canvasEl = canvas;
+
+		  if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {
+		    opts = canvas;
+		    canvas = undefined;
+		  }
+
+		  if (!canvas) {
+		    canvasEl = getCanvasElement();
+		  }
+
+		  opts = Utils.getOptions(opts);
+		  const size = Utils.getImageWidth(qrData.modules.size, opts);
+
+		  const ctx = canvasEl.getContext('2d');
+		  const image = ctx.createImageData(size, size);
+		  Utils.qrToImageData(image.data, qrData, opts);
+
+		  clearCanvas(ctx, canvasEl, size);
+		  ctx.putImageData(image, 0, 0);
+
+		  return canvasEl
+		};
+
+		exports$1.renderToDataURL = function renderToDataURL (qrData, canvas, options) {
+		  let opts = options;
+
+		  if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {
+		    opts = canvas;
+		    canvas = undefined;
+		  }
+
+		  if (!opts) opts = {};
+
+		  const canvasEl = exports$1.render(qrData, canvas, opts);
+
+		  const type = opts.type || 'image/png';
+		  const rendererOpts = opts.rendererOpts || {};
+
+		  return canvasEl.toDataURL(type, rendererOpts.quality)
+		}; 
+	} (canvas));
+	return canvas;
+}
+
+var svgTag = {};
+
+var hasRequiredSvgTag;
+
+function requireSvgTag () {
+	if (hasRequiredSvgTag) return svgTag;
+	hasRequiredSvgTag = 1;
+	const Utils = requireUtils();
+
+	function getColorAttrib (color, attrib) {
+	  const alpha = color.a / 255;
+	  const str = attrib + '="' + color.hex + '"';
+
+	  return alpha < 1
+	    ? str + ' ' + attrib + '-opacity="' + alpha.toFixed(2).slice(1) + '"'
+	    : str
+	}
+
+	function svgCmd (cmd, x, y) {
+	  let str = cmd + x;
+	  if (typeof y !== 'undefined') str += ' ' + y;
+
+	  return str
+	}
+
+	function qrToPath (data, size, margin) {
+	  let path = '';
+	  let moveBy = 0;
+	  let newRow = false;
+	  let lineLength = 0;
+
+	  for (let i = 0; i < data.length; i++) {
+	    const col = Math.floor(i % size);
+	    const row = Math.floor(i / size);
+
+	    if (!col && !newRow) newRow = true;
+
+	    if (data[i]) {
+	      lineLength++;
+
+	      if (!(i > 0 && col > 0 && data[i - 1])) {
+	        path += newRow
+	          ? svgCmd('M', col + margin, 0.5 + row + margin)
+	          : svgCmd('m', moveBy, 0);
+
+	        moveBy = 0;
+	        newRow = false;
+	      }
+
+	      if (!(col + 1 < size && data[i + 1])) {
+	        path += svgCmd('h', lineLength);
+	        lineLength = 0;
+	      }
+	    } else {
+	      moveBy++;
+	    }
+	  }
+
+	  return path
+	}
+
+	svgTag.render = function render (qrData, options, cb) {
+	  const opts = Utils.getOptions(options);
+	  const size = qrData.modules.size;
+	  const data = qrData.modules.data;
+	  const qrcodesize = size + opts.margin * 2;
+
+	  const bg = !opts.color.light.a
+	    ? ''
+	    : '<path ' + getColorAttrib(opts.color.light, 'fill') +
+	      ' d="M0 0h' + qrcodesize + 'v' + qrcodesize + 'H0z"/>';
+
+	  const path =
+	    '<path ' + getColorAttrib(opts.color.dark, 'stroke') +
+	    ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+
+	  const viewBox = 'viewBox="' + '0 0 ' + qrcodesize + ' ' + qrcodesize + '"';
+
+	  const width = !opts.width ? '' : 'width="' + opts.width + '" height="' + opts.width + '" ';
+
+	  const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path + '</svg>\n';
+
+	  if (typeof cb === 'function') {
+	    cb(null, svgTag);
+	  }
+
+	  return svgTag
+	};
+	return svgTag;
+}
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser;
+	hasRequiredBrowser = 1;
+	const canPromise = requireCanPromise();
+
+	const QRCode = requireQrcode();
+	const CanvasRenderer = requireCanvas();
+	const SvgRenderer = requireSvgTag();
+
+	function renderCanvas (renderFunc, canvas, text, opts, cb) {
+	  const args = [].slice.call(arguments, 1);
+	  const argsNum = args.length;
+	  const isLastArgCb = typeof args[argsNum - 1] === 'function';
+
+	  if (!isLastArgCb && !canPromise()) {
+	    throw new Error('Callback required as last argument')
+	  }
+
+	  if (isLastArgCb) {
+	    if (argsNum < 2) {
+	      throw new Error('Too few arguments provided')
+	    }
+
+	    if (argsNum === 2) {
+	      cb = text;
+	      text = canvas;
+	      canvas = opts = undefined;
+	    } else if (argsNum === 3) {
+	      if (canvas.getContext && typeof cb === 'undefined') {
+	        cb = opts;
+	        opts = undefined;
+	      } else {
+	        cb = opts;
+	        opts = text;
+	        text = canvas;
+	        canvas = undefined;
+	      }
+	    }
+	  } else {
+	    if (argsNum < 1) {
+	      throw new Error('Too few arguments provided')
+	    }
+
+	    if (argsNum === 1) {
+	      text = canvas;
+	      canvas = opts = undefined;
+	    } else if (argsNum === 2 && !canvas.getContext) {
+	      opts = text;
+	      text = canvas;
+	      canvas = undefined;
+	    }
+
+	    return new Promise(function (resolve, reject) {
+	      try {
+	        const data = QRCode.create(text, opts);
+	        resolve(renderFunc(data, canvas, opts));
+	      } catch (e) {
+	        reject(e);
+	      }
+	    })
+	  }
+
+	  try {
+	    const data = QRCode.create(text, opts);
+	    cb(null, renderFunc(data, canvas, opts));
+	  } catch (e) {
+	    cb(e);
+	  }
+	}
+
+	browser.create = QRCode.create;
+	browser.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
+	browser.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
+
+	// only svg for now.
+	browser.toString = renderCanvas.bind(null, function (data, _, opts) {
+	  return SvgRenderer.render(data, opts)
+	});
+	return browser;
+}
+
+requireBrowser();
+
+/** Solana Mainnet (beta) cluster, e.g. https://api.mainnet-beta.solana.com */
+const SOLANA_MAINNET_CHAIN = 'solana:mainnet';
+
+//#region src/base64Utils.ts
+function fromUint8Array(byteArray) {
+	return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function toUint8Array(base64EncodedByteArray) {
+	return new Uint8Array(window.atob(base64EncodedByteArray).split("").map((c) => c.charCodeAt(0)));
+}
+//#endregion
+//#region src/embedded-modal/loadingSpinner.ts
+const modalHtml$1 = `
+<div class="mobile-wallet-adapter-embedded-loading-indicator" role="dialog" aria-modal="true" aria-labelledby="modal-title">
+    <div data-modal-close style="position: absolute; width: 100%; height: 100%;"></div>
+    <div class="mobile-wallet-adapter-embedded-loading-container">
+        <div class="mobile-wallet-adapter-embedded-loading-animation"></div>
+    </div>
+</div>
+`;
+const css$6 = `
+.mobile-wallet-adapter-embedded-loading-indicator {
+    display: flex; /* Use flexbox to center content */
+    justify-content: center; /* Center horizontally */
+    align-items: start; /* Center vertically */
+    position: fixed; /* Stay in place */
+    z-index: 1; /* Sit on top */
+    left: 0;
+    top: 0;
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    background-color: rgba(0,0,0,0.4); /* Black w/ opacity */
+    overflow-y: auto; /* enable scrolling */
+}
+
+.mobile-wallet-adapter-embedded-loading-container {
+    display: flex;
+    margin: auto;
+}
+
+.mobile-wallet-adapter-embedded-loading-animation {
+    position: relative;
+    left: -9999px;
+    width: 10px;
+    height: 10px;
+    border-radius: 5px;
+    background-color: var(--spinner-color);
+    color: var(--spinner-color);
+    box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                9999px 0 0 0 var(--spinner-color), 
+                10014px 0 0 0 var(--spinner-color);
+    animation: dot-typing 1.5s infinite linear;
+}
+
+@keyframes dot-typing {
+    0% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+    16.667% {
+        box-shadow: 9984px -10px 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+    33.333% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+    50% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px -10px 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+    66.667% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+    83.333% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px -10px 0 0 var(--spinner-color);
+    }
+    100% {
+        box-shadow: 9984px 0 0 0 var(--spinner-color), 
+                    9999px 0 0 0 var(--spinner-color), 
+                    10014px 0 0 0 var(--spinner-color);
+    }
+}
+`;
+var EmbeddedLoadingSpinner = class {
+	#root = null;
+	#eventListeners = {};
+	#listenersAttached = false;
+	dom = null;
+	constructor() {
+		this.init = this.init.bind(this);
+		this.#root = document.getElementById("mobile-wallet-adapter-embedded-root-ui");
+	}
+	async init() {
+		console.log("Injecting modal");
+		this.#injectHTML();
+	}
+	open = () => {
+		console.debug("Modal open");
+		this.#attachEventListeners();
+		if (this.#root) this.#root.style.display = "flex";
+	};
+	close = (event = void 0) => {
+		console.debug("Modal close");
+		this.#removeEventListeners();
+		if (this.#root) this.#root.style.display = "none";
+		this.#eventListeners["close"]?.forEach((listener) => listener(event));
+	};
+	addEventListener(event, listener) {
+		this.#eventListeners[event]?.push(listener) || (this.#eventListeners[event] = [listener]);
+		return () => this.removeEventListener(event, listener);
+	}
+	removeEventListener(event, listener) {
+		this.#eventListeners[event] = this.#eventListeners[event]?.filter((existingListener) => listener !== existingListener);
+	}
+	#injectHTML() {
+		if (this.dom) return;
+		this.#root = document.createElement("div");
+		this.#root.id = "mobile-wallet-adapter-embedded-root-ui";
+		this.#root.innerHTML = modalHtml$1;
+		this.#root.style.display = "none";
+		const styles = document.createElement("style");
+		styles.id = "mobile-wallet-adapter-embedded-modal-styles";
+		styles.textContent = css$6;
+		const host = document.createElement("div");
+		this.dom = host.attachShadow({ mode: "closed" });
+		host.style.setProperty("--spinner-color", "#FFFFFF");
+		this.dom.appendChild(styles);
+		this.dom.appendChild(this.#root);
+		document.body.appendChild(host);
+	}
+	#attachEventListeners() {
+		if (!this.#root || this.#listenersAttached) return;
+		[...this.#root.querySelectorAll("[data-modal-close]")].forEach((closer) => closer?.addEventListener("click", (event) => {
+			this.close(event);
+		}));
+		window.addEventListener("load", this.close);
+		document.addEventListener("keydown", this.#handleKeyDown);
+		this.#listenersAttached = true;
+	}
+	#removeEventListeners() {
+		if (!this.#listenersAttached) return;
+		window.removeEventListener("load", this.close);
+		document.removeEventListener("keydown", this.#handleKeyDown);
+		if (!this.#root) return;
+		[...this.#root.querySelectorAll("[data-modal-close]")].forEach((closer) => closer?.removeEventListener("click", this.close));
+		this.#listenersAttached = false;
+	}
+	#handleKeyDown = (event) => {
+		if (event.key === "Escape") this.close(event);
+	};
+};
+//#endregion
+//#region src/embedded-modal/modal.ts
+const modalHtml = `
+<div class="mobile-wallet-adapter-embedded-modal-container" role="dialog" aria-modal="true" aria-labelledby="modal-title">
+    <div data-modal-close style="position: absolute; width: 100%; height: 100%;"></div>
+	<div class="mobile-wallet-adapter-embedded-modal-card">
+		<div>
+			<button data-modal-close class="mobile-wallet-adapter-embedded-modal-close">
+				<svg width="14" height="14">
+					<path d="M 6.7125,8.3036995 1.9082,13.108199 c -0.2113,0.2112 -0.4765,0.3168 -0.7957,0.3168 -0.3192,0 -0.5844,-0.1056 -0.7958,-0.3168 C 0.1056,12.896899 0,12.631699 0,12.312499 c 0,-0.3192 0.1056,-0.5844 0.3167,-0.7958 L 5.1212,6.7124995 0.3167,1.9082 C 0.1056,1.6969 0,1.4317 0,1.1125 0,0.7933 0.1056,0.5281 0.3167,0.3167 0.5281,0.1056 0.7933,0 1.1125,0 1.4317,0 1.6969,0.1056 1.9082,0.3167 L 6.7125,5.1212 11.5167,0.3167 C 11.7281,0.1056 11.9933,0 12.3125,0 c 0.3192,0 0.5844,0.1056 0.7957,0.3167 0.2112,0.2114 0.3168,0.4766 0.3168,0.7958 0,0.3192 -0.1056,0.5844 -0.3168,0.7957 L 8.3037001,6.7124995 13.1082,11.516699 c 0.2112,0.2114 0.3168,0.4766 0.3168,0.7958 0,0.3192 -0.1056,0.5844 -0.3168,0.7957 -0.2113,0.2112 -0.4765,0.3168 -0.7957,0.3168 -0.3192,0 -0.5844,-0.1056 -0.7958,-0.3168 z" />
+				</svg>
+			</button>
+		</div>
+		<div class="mobile-wallet-adapter-embedded-modal-content"></div>
+	</div>
+</div>
+`;
+const css$5 = `
+.mobile-wallet-adapter-embedded-modal-container {
+    display: flex; /* Use flexbox to center content */
+    justify-content: center; /* Center horizontally */
+    align-items: center; /* Center vertically */
+    position: fixed; /* Stay in place */
+    z-index: 2147483647; /* Sit on top */
+    left: 0;
+    top: 0;
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    background-color: rgba(0,0,0,0.4); /* Black w/ opacity */
+    overflow-y: auto; /* enable scrolling */
+}
+
+.mobile-wallet-adapter-embedded-modal-card {
+    display: flex;
+    flex-direction: column;
+    margin: auto 20px;
+    max-width: 780px;
+    padding: 20px;
+    border-radius: 24px;
+    background: #ffffff;
+    font-family: "Inter Tight", "PT Sans", Calibri, sans-serif;
+    transform: translateY(-200%);
+    animation: slide-in 0.5s forwards;
+}
+
+@keyframes slide-in {
+    100% { transform: translateY(0%); }
+}
+
+.mobile-wallet-adapter-embedded-modal-close {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 32px;
+    height: 32px;
+    cursor: pointer;
+    background: #e4e9e9;
+    border: none;
+    border-radius: 50%;
+}
+
+.mobile-wallet-adapter-embedded-modal-close:focus-visible {
+    outline-color: red;
+}
+
+.mobile-wallet-adapter-embedded-modal-close svg {
+    fill: #546266;
+    transition: fill 200ms ease 0s;
+}
+
+.mobile-wallet-adapter-embedded-modal-close:hover svg {
+    fill: #fff;
+}
+`;
+const fonts = `
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter+Tight:ital,wght@0,100..900;1,100..900&display=swap" rel="stylesheet">
+`;
+var EmbeddedModal = class {
+	#root = null;
+	#eventListeners = {};
+	#listenersAttached = false;
+	dom = null;
+	constructor() {
+		this.init = this.init.bind(this);
+		this.#root = document.getElementById("mobile-wallet-adapter-embedded-root-ui");
+	}
+	async init() {
+		console.log("Injecting modal");
+		this.#injectHTML();
+	}
+	open = () => {
+		console.debug("Modal open");
+		this.#attachEventListeners();
+		if (this.#root) this.#root.style.display = "flex";
+	};
+	close = (event = void 0) => {
+		console.debug("Modal close");
+		this.#removeEventListeners();
+		if (this.#root) this.#root.style.display = "none";
+		this.#eventListeners["close"]?.forEach((listener) => listener(event));
+	};
+	addEventListener(event, listener) {
+		this.#eventListeners[event]?.push(listener) || (this.#eventListeners[event] = [listener]);
+		return () => this.removeEventListener(event, listener);
+	}
+	removeEventListener(event, listener) {
+		this.#eventListeners[event] = this.#eventListeners[event]?.filter((existingListener) => listener !== existingListener);
+	}
+	#injectHTML() {
+		if (document.getElementById("mobile-wallet-adapter-embedded-root-ui")) {
+			if (!this.#root) this.#root = document.getElementById("mobile-wallet-adapter-embedded-root-ui");
+			return;
+		}
+		this.#root = document.createElement("div");
+		this.#root.id = "mobile-wallet-adapter-embedded-root-ui";
+		this.#root.innerHTML = modalHtml;
+		this.#root.style.display = "none";
+		const content = this.#root.querySelector(".mobile-wallet-adapter-embedded-modal-content");
+		if (content) content.innerHTML = this.contentHtml;
+		const styles = document.createElement("style");
+		styles.id = "mobile-wallet-adapter-embedded-modal-styles";
+		styles.textContent = css$5 + this.contentStyles;
+		const host = document.createElement("div");
+		host.innerHTML = fonts;
+		this.dom = host.attachShadow({ mode: "closed" });
+		this.dom.appendChild(styles);
+		this.dom.appendChild(this.#root);
+		document.body.appendChild(host);
+	}
+	#attachEventListeners() {
+		if (!this.#root || this.#listenersAttached) return;
+		[...this.#root.querySelectorAll("[data-modal-close]")].forEach((closer) => closer?.addEventListener("click", this.close));
+		window.addEventListener("load", this.close);
+		document.addEventListener("keydown", this.#handleKeyDown);
+		this.#listenersAttached = true;
+	}
+	#removeEventListeners() {
+		if (!this.#listenersAttached) return;
+		window.removeEventListener("load", this.close);
+		document.removeEventListener("keydown", this.#handleKeyDown);
+		if (!this.#root) return;
+		[...this.#root.querySelectorAll("[data-modal-close]")].forEach((closer) => closer?.removeEventListener("click", this.close));
+		this.#listenersAttached = false;
+	}
+	#handleKeyDown = (event) => {
+		if (event.key === "Escape") this.close(event);
+	};
+};
+//#endregion
+//#region src/embedded-modal/localConnectionModal.ts
+var LocalConnectionModal = class extends EmbeddedModal {
+	contentStyles = css$3;
+	contentHtml = ErrorDialogHtml$3;
+	initWithCallback(callback) {
+		super.init();
+		this.#prepareLaunchAction(callback);
+	}
+	#prepareLaunchAction(callback) {
+		const launchButton = this.dom?.getElementById("mobile-wallet-adapter-launch-action");
+		const listener = async () => {
+			launchButton?.removeEventListener("click", listener);
+			this.close();
+			callback();
+		};
+		launchButton?.addEventListener("click", listener);
+	}
+};
+const ErrorDialogHtml$3 = `
+<svg class="mobile-wallet-adapter-embedded-modal-launch-icon" width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M21.6 48C7.2 48 0 40.8 0 26.4V21.6C0 7.2 7.2 0 21.6 0H26.4C40.8 0 48 7.2 48 21.6V26.4C48 40.8 40.8 48 26.4 48H21.6Z" fill="#15994E"/>
+    <mask id="mask0_189_522" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="8" y="8" width="32" height="32">
+        <rect x="8" y="8" width="32" height="32" fill="#D9D9D9"/>
+    </mask>
+    <g mask="url(#mask0_189_522)">
+        <mask id="mask1_189_522" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="8" y="8" width="32" height="32">
+            <rect x="8" y="8" width="32" height="32" fill="#D9D9D9"/>
+        </mask>
+        <g mask="url(#mask1_189_522)">
+            <path d="M22.1092 26.1208L19.4498 23.4615C19.1736 23.1851 18.8253 23.0468 18.4048 23.0468C17.9846 23.0468 17.6363 23.1851 17.3598 23.4615C17.0836 23.7377 16.9468 24.0861 16.9495 24.5065C16.9522 24.9267 17.0916 25.275 17.3678 25.5512L21.0405 29.2238C21.3463 29.5276 21.7031 29.6795 22.1108 29.6795C22.5184 29.6795 22.8742 29.5276 23.1782 29.2238L30.5918 21.8098C30.8683 21.5336 31.0065 21.1867 31.0065 20.7692C31.0065 20.3514 30.8683 20.0044 30.5918 19.7282C30.3156 19.4517 29.9673 19.3135 29.5468 19.3135C29.1266 19.3135 28.7784 19.4517 28.5022 19.7282L22.1092 26.1208ZM23.9998 37.6042C22.113 37.6042 20.3425 37.2473 18.6885 36.5335C17.0343 35.8197 15.5954 34.8512 14.3718 33.6278C13.1485 32.4043 12.18 30.9654 11.4662 29.3112C10.7524 27.6572 10.3955 25.8867 10.3955 23.9998C10.3955 22.113 10.7524 20.3425 11.4662 18.6885C12.18 17.0343 13.1485 15.5954 14.3718 14.3718C15.5954 13.1485 17.0343 12.18 18.6885 11.4662C20.3425 10.7524 22.113 10.3955 23.9998 10.3955C25.8867 10.3955 27.6572 10.7524 29.3112 11.4662C30.9654 12.18 32.4043 13.1485 33.6278 14.3718C34.8512 15.5954 35.8197 17.0343 36.5335 18.6885C37.2473 20.3425 37.6042 22.113 37.6042 23.9998C37.6042 25.8867 37.2473 27.6572 36.5335 29.3112C35.8197 30.9654 34.8512 32.4043 33.6278 33.6278C32.4043 34.8512 30.9654 35.8197 29.3112 36.5335C27.6572 37.2473 25.8867 37.6042 23.9998 37.6042Z" fill="white"/>
+        </g>
+    </g>
+</svg>
+<div class="mobile-wallet-adapter-embedded-modal-title">Ready to connect!</div>
+<div>
+    <button data-modal-action id="mobile-wallet-adapter-launch-action" class="mobile-wallet-adapter-embedded-modal-launch-action">
+        Connect Wallet
+    </button>
+</div>
+`;
+const css$3 = `
+.mobile-wallet-adapter-embedded-modal-close {
+    display: none;
+}
+.mobile-wallet-adapter-embedded-modal-content {
+    text-align: center;
+    min-width: 300px;
+}
+.mobile-wallet-adapter-embedded-modal-launch-icon {
+    margin-top: 24px;
+}
+.mobile-wallet-adapter-embedded-modal-title {
+    margin: 18px 100px 30px 100px;
+    color: #000000;
+    font-size: 2.75em;
+    font-weight: 600;
+}
+.mobile-wallet-adapter-embedded-modal-launch-action {
+    display: block;
+    width: 100%;
+    height: 56px;
+    font-size: 1.25em;
+    background: #000000;
+    color: #FFFFFF;
+    border-radius: 18px;
+}
+/* Smaller screens */
+@media all and (max-width: 600px) {
+    .mobile-wallet-adapter-embedded-modal-title {
+        font-size: 1.5em;
+        margin-right: 12px;
+        margin-left: 12px;
+    }
+}
+`;
+//#endregion
+//#region src/embedded-modal/loopbackBlockedModal.ts
+var LoopbackPermissionBlockedModal = class extends EmbeddedModal {
+	contentStyles = css$2;
+	get contentHtml() {
+		const instructions = getIsPwaLaunchedAsApp() ? "Long press the app icon on your home screen to open site settings" : "Tap the lock or settings icon in the address bar to open site settings";
+		return ErrorDialogHtml$2.replace("{{PERMISSION_INSTRUCTION_DETAIL}}", instructions);
+	}
+	async init() {
+		super.init();
+		this.#prepareLaunchAction();
+	}
+	#prepareLaunchAction() {
+		const launchButton = this.dom?.getElementById("mobile-wallet-adapter-launch-action");
+		const listener = async (event) => {
+			launchButton?.removeEventListener("click", listener);
+			this.close(event);
+		};
+		launchButton?.addEventListener("click", listener);
+	}
+};
+const ErrorDialogHtml$2 = `
+<div class="mobile-wallet-adapter-embedded-modal-header">
+    Local Wallet Connection
+</div>
+<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M21.6 48C7.2 48 0 40.8 0 26.4V21.6C0 7.2 7.2 0 21.6 0H26.4C40.8 0 48 7.2 48 21.6V26.4C48 40.8 40.8 48 26.4 48H21.6Z" fill="#ED1515"/>
+    <mask id="mask0_147_1364" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="8" y="8" width="32" height="32">
+        <rect x="8" y="8" width="32" height="32" fill="#D9D9D9"/>
+    </mask>
+    <g mask="url(#mask0_147_1364)">
+        <path d="M20.1398 36.2705C19.7363 36.2705 19.3508 36.1945 18.9835 36.0425C18.6162 35.8907 18.2916 35.674 18.0098 35.3922L12.6072 29.9895C12.3254 29.7077 12.1086 29.3832 11.9568 29.0158C11.8048 28.6485 11.7288 28.2631 11.7288 27.8595V20.1395C11.7288 19.736 11.8048 19.3505 11.9568 18.9832C12.1086 18.6158 12.3254 18.2913 12.6072 18.0095L18.0098 12.6068C18.2916 12.3251 18.6162 12.1083 18.9835 11.9565C19.3508 11.8045 19.7363 11.7285 20.1398 11.7285H27.8598C28.2634 11.7285 28.6488 11.8045 29.0162 11.9565C29.3835 12.1083 29.708 12.3251 29.9898 12.6068L35.3925 18.0095C35.6743 18.2913 35.891 18.6158 36.0428 18.9832C36.1948 19.3505 36.2708 19.736 36.2708 20.1395V27.8595C36.2708 28.2631 36.1948 28.6485 36.0428 29.0158C35.891 29.3832 35.6743 29.7077 35.3925 29.9895L29.9898 35.3922C29.708 35.674 29.3835 35.8907 29.0162 36.0425C28.6488 36.1945 28.2634 36.2705 27.8598 36.2705H20.1398ZM20.1732 33.2372H27.8265L33.2375 27.8262V20.1728L27.8265 14.7618H20.1732L14.7622 20.1728V27.8262L20.1732 33.2372ZM23.9998 25.9538L26.7868 28.7408C27.0473 29.0013 27.3729 29.1302 27.7638 29.1275C28.1549 29.1248 28.4807 28.9933 28.7412 28.7328C29.0016 28.4724 29.1318 28.1466 29.1318 27.7555C29.1318 27.3646 29.0016 27.039 28.7412 26.7785L25.9542 23.9995L28.7412 21.2125C29.0016 20.9521 29.1318 20.6264 29.1318 20.2355C29.1318 19.8444 29.0016 19.5186 28.7412 19.2582C28.4807 18.9977 28.1549 18.8675 27.7638 18.8675C27.3729 18.8675 27.0473 18.9977 26.7868 19.2582L23.9998 22.0452L21.2128 19.2582C20.9524 18.9977 20.628 18.8675 20.2398 18.8675C19.8514 18.8675 19.5269 18.9977 19.2665 19.2582C19.006 19.5186 18.8758 19.8444 18.8758 20.2355C18.8758 20.6264 19.006 20.9521 19.2665 21.2125L22.0455 23.9995L19.2585 26.7865C18.998 27.047 18.8692 27.3713 18.8718 27.7595C18.8745 28.148 19.006 28.4724 19.2665 28.7328C19.5269 28.9933 19.8527 29.1235 20.2438 29.1235C20.6347 29.1235 20.9604 28.9933 21.2208 28.7328L23.9998 25.9538Z" fill="black"/>
+    </g>
+</svg>
+<div class="mobile-wallet-adapter-embedded-modal-title">
+    Your wallet connection is blocked
+</div>
+<div id="mobile-wallet-adapter-local-launch-message" class="mobile-wallet-adapter-embedded-modal-subtitle">
+    Visit site settings in the address bar and allow "Apps on Device".
+</div>
+
+<div class="mobile-wallet-adapter-embedded-modal-divider"><hr></div>
+<div class="mobile-wallet-adapter-embedded-modal-footer">
+    <div class="mobile-wallet-adapter-embedded-modal-details">
+        <!-- Clickable header (label associated with the checkbox) -->
+      	<label for="collapsible-1" class="mobile-wallet-adapter-embedded-modal-details-collapsible-header">
+            <!-- Hidden checkbox to track state -->
+            <input type="checkbox" id="collapsible-1" class="mobile-wallet-adapter-embedded-modal-details-collapsible-input">
+            <span class="mobile-wallet-adapter-embedded-modal-details-collapsible-header-label">
+              See details
+            </span>
+            <svg class="mobile-wallet-adapter-embedded-modal-details-collapsible-header-icon" width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+              <mask id="mask0_147_1382" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="24" height="24">
+                <rect width="24" height="24" fill="#D9D9D9"/>
+              </mask>
+              <g mask="url(#mask0_147_1382)">
+                <path d="M11.9999 17.0811C11.8506 17.0811 11.7087 17.0563 11.5741 17.0067C11.4395 16.957 11.3162 16.8762 11.2042 16.7643L6.57924 12.1393C6.36801 11.9281 6.26656 11.667 6.27489 11.3561C6.28322 11.0453 6.39301 10.7842 6.60424 10.573C6.81547 10.3618 7.08069 10.2561 7.39989 10.2561C7.71909 10.2561 7.9843 10.3618 8.19554 10.573L11.9999 14.3773L15.8292 10.548C16.0405 10.3368 16.3015 10.2353 16.6124 10.2436C16.9233 10.252 17.1843 10.3618 17.3955 10.573C17.6068 10.7842 17.7124 11.0494 17.7124 11.3686C17.7124 11.6878 17.6068 11.9531 17.3955 12.1643L12.7955 16.7643C12.6836 16.8762 12.5603 16.957 12.4257 17.0067C12.2911 17.0563 12.1492 17.0811 11.9999 17.0811Z" fill="black"/>
+              </g>
+            </svg>
+      	</label>
+        
+        <!-- Content to show/hide -->
+        <ul class="mobile-wallet-adapter-embedded-modal-details-collapsible-content">
+            <li>{{PERMISSION_INSTRUCTION_DETAIL}}</li>
+            <li>Allow "Apps on Device"</li>
+        </ul>
+    </div>
+</div>
+<div>
+    <button data-modal-action id="mobile-wallet-adapter-launch-action" class="mobile-wallet-adapter-embedded-modal-launch-action">
+        Got it
+    </button>
+</div>
+`;
+const css$2 = `
+.mobile-wallet-adapter-embedded-modal-close {
+    display: none;
+}
+.mobile-wallet-adapter-embedded-modal-content {
+    text-align: center;
+}
+.mobile-wallet-adapter-embedded-modal-header {
+    margin: 18px auto 30px auto;
+    color: #7D9093;
+    font-size: 1.0em;
+    font-weight: 500;
+}
+.mobile-wallet-adapter-embedded-modal-title {
+    margin: 18px 100px auto 100px;
+    color: #000000;
+    font-size: 2.75em;
+    font-weight: 600;
+}
+.mobile-wallet-adapter-embedded-modal-subtitle {
+    margin: 12px 60px 30px 60px;
+    color: #7D9093;
+    font-size: 1.25em;
+    font-weight: 400;
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-header {
+    display: flex;
+    flex-direction: row;
+  	justify-content: space-between;
+    margin: 10px auto 10px auto;
+    color: #000000;
+    font-size: 1.5em;
+    font-weight: 600;
+    cursor: pointer; /* Show pointer on hover */
+    transition: background 0.2s ease; /* Smooth background change */
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-header-icon {
+  	transition: rotate 0.3s ease;
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-input {
+  	display: none; /* Hide the checkbox */
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-content {
+    margin: 0px auto 40px auto;
+    max-height: 0px; /* Collapse content */
+    overflow: hidden; /* Hide overflow when collapsed */
+    transition: max-height 0.3s ease; /* Smooth transition */
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-content li {
+    margin: 20px auto;
+    color: #000000;
+    font-size: 1.25em;
+    font-weight: 400;
+    text-align: left;
+}
+/* When checkbox is checked, show content */
+.mobile-wallet-adapter-embedded-modal-details-collapsible-header:has(> input:checked) ~ .mobile-wallet-adapter-embedded-modal-details-collapsible-content {
+  	max-height: 300px;
+}
+.mobile-wallet-adapter-embedded-modal-details-collapsible-header:has(> input:checked) > .mobile-wallet-adapter-embedded-modal-details-collapsible-header-icon {
+  	rotate: 180deg;
+}
+.mobile-wallet-adapter-embedded-modal-launch-action {
+    display: block;
+    width: 100%;
+    height: 56px;
+    /*margin-top: 40px;*/
+    font-size: 1.25em;
+    /*line-height: 24px;*/
+    /*letter-spacing: -1%;*/
+    background: #000000;
+    color: #FFFFFF;
+    border-radius: 18px;
+}
+/* Smaller screens */
+@media all and (max-width: 600px) {
+    .mobile-wallet-adapter-embedded-modal-title {
+        font-size: 1.75em;
+        margin-right: 12px;
+        margin-left: 12px;
+    }
+    .mobile-wallet-adapter-embedded-modal-subtitle {
+        margin-right: 12px;
+        margin-left: 12px;
+    }
+}
+`;
+//#endregion
+//#region src/embedded-modal/loopbackPermissionModal.ts
+var LoopbackPermissionModal = class extends EmbeddedModal {
+	contentStyles = css$1;
+	contentHtml = ErrorDialogHtml$1;
+	async init() {
+		super.init();
+		this.#prepareLaunchAction();
+	}
+	#prepareLaunchAction() {
+		const launchButton = this.dom?.getElementById("mobile-wallet-adapter-launch-action");
+		const listener = async () => {
+			launchButton?.removeEventListener("click", listener);
+			try {
+				await fetch("http://localhost");
+			} catch {}
+			this.close();
+		};
+		launchButton?.addEventListener("click", listener);
+	}
+};
+const ErrorDialogHtml$1 = `
+<div class="mobile-wallet-adapter-embedded-modal-title">Allow connections to your wallet</div>
+<div id="mobile-wallet-adapter-local-launch-message" class="mobile-wallet-adapter-embedded-modal-subtitle">
+    Tap "Allow" on the next screen
+</div>
+<svg class="mobile-wallet-adapter-embedded-modal-permission-prompt-mock" xmlns="http://www.w3.org/2000/svg" width="281" height="83" viewBox="0 0 281 83" fill="none">
+    <rect width="281" height="83" rx="22" fill="#F0F3F5"/>
+    <path d="M254.194 64L252.626 56.657H254.047L254.866 61.452L254.985 62.278H255.02L255.146 61.452L255.993 57.497H257.4L258.254 61.431L258.373 62.278H258.415L258.534 61.431L259.346 56.657H260.718L259.143 64H257.673L256.826 59.961L256.693 59.093H256.651L256.511 59.961L255.664 64H254.194Z" fill="black"/>
+    <path d="M248.837 64.231C248.147 64.231 247.54 64.07 247.017 63.748C246.495 63.426 246.086 62.978 245.792 62.404C245.498 61.83 245.351 61.1673 245.351 60.416V60.241C245.351 59.4897 245.498 58.827 245.792 58.253C246.086 57.679 246.495 57.2333 247.017 56.916C247.54 56.594 248.147 56.433 248.837 56.433C249.528 56.433 250.135 56.594 250.657 56.916C251.18 57.2333 251.588 57.679 251.882 58.253C252.176 58.827 252.323 59.4897 252.323 60.241V60.416C252.323 61.1673 252.176 61.83 251.882 62.404C251.588 62.978 251.18 63.426 250.657 63.748C250.135 64.07 249.528 64.231 248.837 64.231ZM248.837 62.824C249.43 62.824 249.897 62.607 250.237 62.173C250.583 61.7343 250.755 61.1417 250.755 60.395V60.262C250.755 59.5107 250.583 58.918 250.237 58.484C249.897 58.05 249.43 57.833 248.837 57.833C248.249 57.833 247.783 58.05 247.437 58.484C247.092 58.918 246.919 59.5107 246.919 60.262V60.395C246.919 61.1417 247.092 61.7343 247.437 62.173C247.783 62.607 248.249 62.824 248.837 62.824Z" fill="black"/>
+    <path d="M242.298 64.231C241.467 64.231 240.814 63.993 240.338 63.517C239.866 63.0364 239.631 62.3737 239.631 61.529V53.78H241.178V61.389C241.178 62.3317 241.591 62.803 242.417 62.803C242.65 62.803 242.865 62.7587 243.061 62.67C243.257 62.5814 243.464 62.4367 243.684 62.236L244.538 63.377C244.225 63.6664 243.884 63.881 243.516 64.021C243.152 64.161 242.746 64.231 242.298 64.231ZM237.51 55.061V53.78H240.611V55.061H237.51Z" fill="black"/>
+    <path d="M234.463 64.231C233.633 64.231 232.979 63.993 232.503 63.517C232.032 63.0364 231.796 62.3737 231.796 61.529V53.78H233.343V61.389C233.343 62.3317 233.756 62.803 234.582 62.803C234.816 62.803 235.03 62.7587 235.226 62.67C235.422 62.5814 235.63 62.4367 235.849 62.236L236.703 63.377C236.391 63.6664 236.05 63.881 235.681 64.021C235.317 64.161 234.911 64.231 234.463 64.231ZM229.675 55.061V53.78H232.776V55.061H229.675Z" fill="black"/>
+    <path d="M221.442 64L224.557 53.976H226.132L229.233 64H227.581L225.642 56.972L225.341 55.761H225.299L225.005 56.972L223.073 64H221.442ZM222.835 61.634L223.255 60.29H227.371L227.805 61.634H222.835Z" fill="black"/>
+    <path d="M178.261 64L175.034 60.066V60.024L178.121 56.657H180.011L176.504 60.423V59.632L180.165 64H178.261ZM173.543 64V53.78H175.097V64H173.543Z" fill="#7D9093" fill-opacity="0.5"/>
+    <path d="M169.306 64.224C168.588 64.224 167.958 64.0653 167.416 63.748C166.88 63.426 166.462 62.9803 166.163 62.411C165.865 61.837 165.715 61.1673 165.715 60.402V60.248C165.715 59.4873 165.862 58.8223 166.156 58.253C166.45 57.679 166.863 57.2333 167.395 56.916C167.927 56.594 168.546 56.433 169.25 56.433C169.978 56.433 170.59 56.6056 171.084 56.951C171.579 57.2917 171.955 57.777 172.211 58.407L170.874 58.995C170.72 58.6123 170.508 58.323 170.237 58.127C169.967 57.9263 169.633 57.826 169.236 57.826C168.63 57.826 168.149 58.0383 167.794 58.463C167.444 58.883 167.269 59.4616 167.269 60.199V60.465C167.269 61.1837 167.454 61.7577 167.822 62.187C168.196 62.6163 168.69 62.831 169.306 62.831C169.712 62.831 170.06 62.733 170.349 62.537C170.639 62.341 170.877 62.0423 171.063 61.641L172.379 62.285C172.188 62.6957 171.941 63.0457 171.637 63.335C171.334 63.6243 170.986 63.846 170.594 64C170.202 64.1493 169.773 64.224 169.306 64.224Z" fill="#7D9093" fill-opacity="0.5"/>
+    <path d="M161.003 64.231C160.312 64.231 159.706 64.07 159.183 63.748C158.66 63.426 158.252 62.978 157.958 62.404C157.664 61.83 157.517 61.1673 157.517 60.416V60.241C157.517 59.4897 157.664 58.827 157.958 58.253C158.252 57.679 158.66 57.2333 159.183 56.916C159.706 56.594 160.312 56.433 161.003 56.433C161.694 56.433 162.3 56.594 162.823 56.916C163.346 57.2333 163.754 57.679 164.048 58.253C164.342 58.827 164.489 59.4897 164.489 60.241V60.416C164.489 61.1673 164.342 61.83 164.048 62.404C163.754 62.978 163.346 63.426 162.823 63.748C162.3 64.07 161.694 64.231 161.003 64.231ZM161.003 62.824C161.596 62.824 162.062 62.607 162.403 62.173C162.748 61.7343 162.921 61.1417 162.921 60.395V60.262C162.921 59.5107 162.748 58.918 162.403 58.484C162.062 58.05 161.596 57.833 161.003 57.833C160.415 57.833 159.948 58.05 159.603 58.484C159.258 58.918 159.085 59.5107 159.085 60.262V60.395C159.085 61.1417 159.258 61.7343 159.603 62.173C159.948 62.607 160.415 62.824 161.003 62.824Z" fill="#7D9093" fill-opacity="0.5"/>
+    <path d="M154.463 64.231C153.633 64.231 152.979 63.993 152.503 63.517C152.032 63.0364 151.796 62.3737 151.796 61.529V53.78H153.343V61.389C153.343 62.3317 153.756 62.803 154.582 62.803C154.816 62.803 155.03 62.7587 155.226 62.67C155.422 62.5814 155.63 62.4367 155.849 62.236L156.703 63.377C156.391 63.6664 156.05 63.881 155.681 64.021C155.317 64.161 154.911 64.231 154.463 64.231ZM149.675 55.061V53.78H152.776V55.061H149.675Z" fill="#7D9093" fill-opacity="0.5"/>
+    <path d="M142.24 64V53.976H145.544C146.421 53.976 147.112 54.1953 147.616 54.634C148.12 55.0726 148.372 55.6583 148.372 56.391V56.566C148.372 57.0886 148.246 57.5366 147.994 57.91C147.742 58.2833 147.38 58.5586 146.909 58.736V58.792C147.492 58.9226 147.947 59.2003 148.274 59.625C148.605 60.045 148.771 60.5606 148.771 61.172V61.361C148.771 61.893 148.645 62.3573 148.393 62.754C148.145 63.1506 147.795 63.4586 147.343 63.678C146.895 63.8926 146.365 64 145.754 64H142.24ZM143.794 62.656H145.572C146.085 62.656 146.482 62.5253 146.762 62.264C147.042 62.0026 147.182 61.6293 147.182 61.144V60.99C147.182 60.5046 147.037 60.1313 146.748 59.87C146.463 59.604 146.05 59.471 145.509 59.471H143.36V58.183H145.32C145.791 58.183 146.153 58.064 146.405 57.826C146.657 57.588 146.783 57.2496 146.783 56.811V56.685C146.783 56.2416 146.657 55.9033 146.405 55.67C146.157 55.4366 145.796 55.32 145.32 55.32H143.794V62.656Z" fill="#7D9093" fill-opacity="0.5"/>
+    <rect x="18" y="17" width="246" height="7" rx="3.5" fill="#7D9093" fill-opacity="0.26"/>
+    <rect x="18" y="33" width="82" height="7" rx="3.5" fill="#7D9093" fill-opacity="0.26"/>
+</svg>
+<div>
+    <button data-modal-action id="mobile-wallet-adapter-launch-action" class="mobile-wallet-adapter-embedded-modal-launch-action">
+        Continue to Allow
+    </button>
+</div>
+`;
+const css$1 = `
+.mobile-wallet-adapter-embedded-modal-close {
+    display: none;
+}
+.mobile-wallet-adapter-embedded-modal-content {
+    text-align: center;
+}
+.mobile-wallet-adapter-embedded-modal-title {
+    margin: 18px 100px auto 100px;
+    color: #000000;
+    font-size: 2.75em;
+    font-weight: 600;
+}
+.mobile-wallet-adapter-embedded-modal-subtitle {
+    margin: 20px 60px 40px 60px;
+    color: #7D9093;
+    font-size: 1.25em;
+    font-weight: 400;
+}
+.mobile-wallet-adapter-embedded-modal-permission-prompt-mock {
+    width: 90%;
+    height: auto;
+    margin: 0 auto 30px auto;
+    display: block;
+}
+.mobile-wallet-adapter-embedded-modal-launch-action {
+    display: block;
+    width: 100%;
+    height: 56px;
+    font-size: 1.25em;
+    background: #000000;
+    color: #FFFFFF;
+    border-radius: 18px;
+}
+/* Smaller screens */
+@media all and (max-width: 600px) {
+    .mobile-wallet-adapter-embedded-modal-title {
+        font-size: 1.5em;
+        margin-right: 12px;
+        margin-left: 12px;
+    }
+    .mobile-wallet-adapter-embedded-modal-subtitle {
+        margin-right: 12px;
+        margin-left: 12px;
+    }
+}
+`;
+function isSolanaMobileWebShell(userAgentString) {
+	return userAgentString.includes("Solana Mobile Web Shell");
+}
+function getIsPwaLaunchedAsApp() {
+	const isAndroidTwa = typeof document !== "undefined" && document.referrer.startsWith("android-app://");
+	if (typeof window == "undefined") return isAndroidTwa;
+	const isStandalone = window.matchMedia("(display-mode: standalone)").matches;
+	const isFullscreen = window.matchMedia("(display-mode: fullscreen)").matches;
+	const isMinimalUI = window.matchMedia("(display-mode: minimal-ui)").matches;
+	return isAndroidTwa || isStandalone || isFullscreen || isMinimalUI;
+}
+async function checkLocalNetworkAccessPermission() {
+	if (typeof navigator !== "undefined" && isSolanaMobileWebShell(navigator.userAgent)) return;
+	try {
+		const lnaPermission = await navigator.permissions.query({ name: "loopback-network" });
+		if (lnaPermission.state === "granted") return;
+		else if (lnaPermission.state === "denied") {
+			const modal = new LoopbackPermissionBlockedModal();
+			modal.init();
+			modal.open();
+			throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_LOOPBACK_ACCESS_BLOCKED, "Local Network Access permission denied");
+		} else if (lnaPermission.state === "prompt") {
+			const modal = new LoopbackPermissionModal();
+			if (await new Promise((resolve, reject) => {
+				modal.addEventListener("close", (event) => {
+					if (event) reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_CANCELLED, "Wallet connection cancelled by user", { event }));
+				});
+				lnaPermission.onchange = () => {
+					lnaPermission.onchange = null;
+					resolve(lnaPermission.state);
+				};
+				modal.init();
+				modal.open();
+			}) === "granted") {
+				const modal = new LocalConnectionModal();
+				await new Promise((resolve, reject) => {
+					modal.addEventListener("close", (event) => {
+						if (event) reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_CANCELLED, "Wallet connection cancelled by user", { event }));
+					});
+					modal.initWithCallback(async () => {
+						resolve(true);
+					});
+					modal.open();
+				});
+				return;
+			} else return await checkLocalNetworkAccessPermission();
+		}
+		throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_LOOPBACK_ACCESS_BLOCKED, "Local Network Access permission unknown");
+	} catch (e) {
+		if (e instanceof TypeError && (e.message.includes("loopback-network") || e.message.includes("local-network-access"))) return;
+		if (e instanceof SolanaMobileWalletAdapterError) throw e;
+		throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_LOOPBACK_ACCESS_BLOCKED, e instanceof Error ? e.message : "Local Network Access permission unknown");
+	}
+}
+//#endregion
+//#region src/icon.ts
+const icon = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik03IDIuNUgxN0MxNy44Mjg0IDIuNSAxOC41IDMuMTcxNTcgMTguNSA0VjIwQzE4LjUgMjAuODI4NCAxNy44Mjg0IDIxLjUgMTcgMjEuNUg3QzYuMTcxNTcgMjEuNSA1LjUgMjAuODI4NCA1LjUgMjBWNEM1LjUgMy4xNzE1NyA2LjE3MTU3IDIuNSA3IDIuNVpNMyA0QzMgMS43OTA4NiA0Ljc5MDg2IDAgNyAwSDE3QzE5LjIwOTEgMCAyMSAxLjc5MDg2IDIxIDRWMjBDMjEgMjIuMjA5MSAxOS4yMDkxIDI0IDE3IDI0SDdDNC43OTA4NiAyNCAzIDIyLjIwOTEgMyAyMFY0Wk0xMSA0LjYxNTM4QzEwLjQ0NzcgNC42MTUzOCAxMCA1LjA2MzEgMTAgNS42MTUzOFY2LjM4NDYyQzEwIDYuOTM2OSAxMC40NDc3IDcuMzg0NjIgMTEgNy4zODQ2MkgxM0MxMy41NTIzIDcuMzg0NjIgMTQgNi45MzY5IDE0IDYuMzg0NjJWNS42MTUzOEMxNCA1LjA2MzEgMTMuNTUyMyA0LjYxNTM4IDEzIDQuNjE1MzhIMTFaIiBmaWxsPSIjRENCOEZGIi8+Cjwvc3ZnPgo=";
+//#endregion
+//#region src/wallet.ts
+const SolanaMobileWalletAdapterWalletName = "Mobile Wallet Adapter";
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+const DEFAULT_FEATURES = [
+	SolanaSignAndSendTransaction,
+	SolanaSignTransaction,
+	SolanaSignMessage,
+	SolanaSignIn
+];
+const WALLET_ASSOCIATION_TIMEOUT = 3e4;
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var LocalSolanaMobileWalletAdapterWallet = class {
+	#listeners = {};
+	#version = "1.0.0";
+	#name = SolanaMobileWalletAdapterWalletName;
+	#url = "https://solanamobile.com/wallets";
+	#icon = icon;
+	#appIdentity;
+	#authorization;
+	#authorizationCache;
+	#connecting = false;
+	/**
+	* Every time the connection is recycled in some way (eg. `disconnect()` is called)
+	* increment this and use it to make sure that `transact` calls from the previous
+	* 'generation' don't continue to do work and throw exceptions.
+	*/
+	#connectionGeneration = 0;
+	#chains = [];
+	#chainSelector;
+	#optionalFeatures;
+	#onWalletNotFound;
+	get version() {
+		return this.#version;
+	}
+	get name() {
+		return this.#name;
+	}
+	get url() {
+		return this.#url;
+	}
+	get icon() {
+		return this.#icon;
+	}
+	get chains() {
+		return this.#chains;
+	}
+	get features() {
+		return {
+			[StandardConnect]: {
+				version: "1.0.0",
+				connect: this.#connect
+			},
+			[StandardDisconnect]: {
+				version: "1.0.0",
+				disconnect: this.#disconnect
+			},
+			[StandardEvents]: {
+				version: "1.0.0",
+				on: this.#on
+			},
+			[SolanaSignMessage]: {
+				version: "1.0.0",
+				signMessage: this.#signMessage
+			},
+			[SolanaSignIn]: {
+				version: "1.0.0",
+				signIn: this.#signIn
+			},
+			...this.#optionalFeatures
+		};
+	}
+	get accounts() {
+		return this.#authorization?.accounts ?? [];
+	}
+	constructor(config) {
+		this.#authorizationCache = config.authorizationCache;
+		this.#appIdentity = config.appIdentity;
+		this.#chains = config.chains;
+		this.#chainSelector = config.chainSelector;
+		this.#onWalletNotFound = config.onWalletNotFound;
+		this.#optionalFeatures = {
+			[SolanaSignAndSendTransaction]: {
+				version: "1.0.0",
+				supportedTransactionVersions: ["legacy", 0],
+				signAndSendTransaction: this.#signAndSendTransaction
+			},
+			[SolanaSignTransaction]: {
+				version: "1.0.0",
+				supportedTransactionVersions: ["legacy", 0],
+				signTransaction: this.#signTransaction
+			}
+		};
+	}
+	get connected() {
+		return !!this.#authorization;
+	}
+	get isAuthorized() {
+		return !!this.#authorization;
+	}
+	get currentAuthorization() {
+		return this.#authorization;
+	}
+	get cachedAuthorizationResult() {
+		return this.#authorizationCache.get();
+	}
+	#on = (event, listener) => {
+		this.#listeners[event]?.push(listener) || (this.#listeners[event] = [listener]);
+		return () => this.#off(event, listener);
+	};
+	#emit(event, ...args) {
+		this.#listeners[event]?.forEach((listener) => listener.apply(null, args));
+	}
+	#off(event, listener) {
+		this.#listeners[event] = this.#listeners[event]?.filter((existingListener) => listener !== existingListener);
+	}
+	#connect = async ({ silent } = {}) => {
+		if (this.#connecting || this.connected) return { accounts: this.accounts };
+		this.#connecting = true;
+		try {
+			if (silent) {
+				const cachedAuthorization = await this.#authorizationCache.get();
+				if (cachedAuthorization) {
+					await this.#handleWalletCapabilitiesResult(cachedAuthorization.capabilities);
+					await this.#handleAuthorizationResult(cachedAuthorization);
+				} else return { accounts: this.accounts };
+			} else await this.#performAuthorization();
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		} finally {
+			this.#connecting = false;
+		}
+		return { accounts: this.accounts };
+	};
+	#performAuthorization = async (signInPayload) => {
+		try {
+			const cachedAuthorizationResult = await this.#authorizationCache.get();
+			if (cachedAuthorizationResult) {
+				this.#handleAuthorizationResult(cachedAuthorizationResult);
+				return cachedAuthorizationResult;
+			}
+			const selectedChain = await this.#chainSelector.select(this.#chains);
+			return await this.#transact(async (wallet) => {
+				const [capabilities, mwaAuthorizationResult] = await Promise.all([wallet.getCapabilities(), wallet.authorize({
+					chain: selectedChain,
+					identity: this.#appIdentity,
+					sign_in_payload: signInPayload
+				})]);
+				const accounts = this.#accountsToWalletStandardAccounts(mwaAuthorizationResult.accounts);
+				const authorization = {
+					...mwaAuthorizationResult,
+					accounts,
+					chain: selectedChain,
+					capabilities
+				};
+				Promise.all([
+					this.#handleWalletCapabilitiesResult(capabilities),
+					this.#authorizationCache.set(authorization),
+					this.#handleAuthorizationResult(authorization)
+				]);
+				return authorization;
+			});
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		}
+	};
+	#handleAuthorizationResult = async (authorization) => {
+		const didPublicKeysChange = this.#authorization == null || this.#authorization?.accounts.length !== authorization.accounts.length || this.#authorization.accounts.some((account, ii) => account.address !== authorization.accounts[ii].address);
+		this.#authorization = authorization;
+		if (didPublicKeysChange) this.#emit("change", { accounts: this.accounts });
+	};
+	#handleWalletCapabilitiesResult = async (capabilities) => {
+		const supportsSignTransaction = capabilities.features.includes("solana:signTransactions");
+		const supportsSignAndSendTransaction = capabilities.supports_sign_and_send_transactions;
+		const didCapabilitiesChange = SolanaSignAndSendTransaction in this.features !== supportsSignAndSendTransaction || SolanaSignTransaction in this.features !== supportsSignTransaction;
+		this.#optionalFeatures = {
+			...(supportsSignAndSendTransaction || !supportsSignAndSendTransaction && !supportsSignTransaction) && { [SolanaSignAndSendTransaction]: {
+				version: "1.0.0",
+				supportedTransactionVersions: ["legacy", 0],
+				signAndSendTransaction: this.#signAndSendTransaction
+			} },
+			...supportsSignTransaction && { [SolanaSignTransaction]: {
+				version: "1.0.0",
+				supportedTransactionVersions: ["legacy", 0],
+				signTransaction: this.#signTransaction
+			} }
+		};
+		if (didCapabilitiesChange) this.#emit("change", { features: this.features });
+	};
+	#performReauthorization = async (wallet, authToken, chain) => {
+		try {
+			const [capabilities, mwaAuthorizationResult] = await Promise.all([this.#authorization?.capabilities ?? await wallet.getCapabilities(), wallet.authorize({
+				auth_token: authToken,
+				identity: this.#appIdentity,
+				chain
+			})]);
+			const accounts = this.#accountsToWalletStandardAccounts(mwaAuthorizationResult.accounts);
+			const authorization = {
+				...mwaAuthorizationResult,
+				accounts,
+				chain,
+				capabilities
+			};
+			Promise.all([this.#authorizationCache.set(authorization), this.#handleAuthorizationResult(authorization)]);
+		} catch (e) {
+			this.#disconnect();
+			throw new Error(getErrorMessage(e), { cause: e });
+		}
+	};
+	#disconnect = async () => {
+		this.#authorizationCache.clear();
+		this.#connecting = false;
+		this.#connectionGeneration++;
+		this.#authorization = void 0;
+		this.#emit("change", { accounts: this.accounts });
+	};
+	#transact = async (callback) => {
+		const walletUriBase = this.#authorization?.wallet_uri_base;
+		const config = walletUriBase ? { baseUri: walletUriBase } : void 0;
+		const currentConnectionGeneration = this.#connectionGeneration;
+		const loadingSpinner = new EmbeddedLoadingSpinner();
+		try {
+			let associating = true;
+			let timeout = void 0;
+			const result = await Promise.race([checkLocalNetworkAccessPermission().then(async () => {
+				loadingSpinner.init();
+				const { wallet, close } = await startScenario(config);
+				associating = false;
+				loadingSpinner.addEventListener("close", (event) => {
+					if (event) close();
+				});
+				loadingSpinner.open();
+				const result = await callback(await wallet);
+				loadingSpinner.close();
+				close();
+				return result;
+			}), new Promise((_, reject) => {
+				timeout = setTimeout(() => {
+					if (associating) reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_CANCELLED, "Wallet connection timed out", { event: void 0 }));
+				}, WALLET_ASSOCIATION_TIMEOUT);
+			})]);
+			clearTimeout(timeout);
+			return result;
+		} catch (e) {
+			loadingSpinner.close();
+			if (this.#connectionGeneration !== currentConnectionGeneration) await new Promise(() => {});
+			if (e instanceof Error && e.name === "SolanaMobileWalletAdapterError" && e.code === "ERROR_WALLET_NOT_FOUND") await this.#onWalletNotFound(this);
+			throw e;
+		}
+	};
+	#assertIsAuthorized = () => {
+		if (!this.#authorization) throw new Error("Wallet not connected");
+		return {
+			authToken: this.#authorization.auth_token,
+			chain: this.#authorization.chain
+		};
+	};
+	#accountsToWalletStandardAccounts = (accounts) => {
+		return accounts.map((account) => {
+			const publicKey = toUint8Array(account.address);
+			return {
+				address: base58.encode(publicKey),
+				publicKey,
+				label: account.label,
+				icon: account.icon,
+				chains: account.chains ?? this.#chains,
+				features: account.features ?? DEFAULT_FEATURES
+			};
+		});
+	};
+	#performSignTransactions = async (transactions) => {
+		const { authToken, chain } = this.#assertIsAuthorized();
+		try {
+			const base64Transactions = transactions.map((tx) => {
+				return fromUint8Array(tx);
+			});
+			return await this.#transact(async (wallet) => {
+				await this.#performReauthorization(wallet, authToken, chain);
+				return (await wallet.signTransactions({ payloads: base64Transactions })).signed_payloads.map(toUint8Array);
+			});
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		}
+	};
+	#performSignAndSendTransaction = async (transaction, options) => {
+		const { authToken, chain } = this.#assertIsAuthorized();
+		try {
+			return await this.#transact(async (wallet) => {
+				const [capabilities] = await Promise.all([wallet.getCapabilities(), this.#performReauthorization(wallet, authToken, chain)]);
+				if (capabilities.supports_sign_and_send_transactions) {
+					const base64Transaction = fromUint8Array(transaction);
+					return (await wallet.signAndSendTransactions({
+						...options,
+						payloads: [base64Transaction]
+					})).signatures.map(toUint8Array)[0];
+				} else throw new Error("connected wallet does not support signAndSendTransaction");
+			});
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		}
+	};
+	#signAndSendTransaction = async (...inputs) => {
+		const outputs = [];
+		for (const input of inputs) {
+			const signature = await this.#performSignAndSendTransaction(input.transaction, input.options);
+			outputs.push({ signature });
+		}
+		return outputs;
+	};
+	#signTransaction = async (...inputs) => {
+		return (await this.#performSignTransactions(inputs.map(({ transaction }) => transaction))).map((signedTransaction) => {
+			return { signedTransaction };
+		});
+	};
+	#signMessage = async (...inputs) => {
+		const { authToken, chain } = this.#assertIsAuthorized();
+		const addresses = inputs.map(({ account }) => fromUint8Array(new Uint8Array(account.publicKey)));
+		const messages = inputs.map(({ message }) => fromUint8Array(message));
+		try {
+			return await this.#transact(async (wallet) => {
+				await this.#performReauthorization(wallet, authToken, chain);
+				return (await wallet.signMessages({
+					addresses,
+					payloads: messages
+				})).signed_payloads.map(toUint8Array).map((signedMessage) => {
+					return {
+						signedMessage,
+						signature: signedMessage.slice(-SIGNATURE_LENGTH_IN_BYTES)
+					};
+				});
+			});
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		}
+	};
+	#signIn = async (...inputs) => {
+		const outputs = [];
+		if (inputs.length > 1) for (const input of inputs) outputs.push(await this.#performSignIn(input));
+		else return [await this.#performSignIn(inputs[0])];
+		return outputs;
+	};
+	#performSignIn = async (input) => {
+		this.#connecting = true;
+		try {
+			const authorizationResult = await this.#performAuthorization({
+				...input,
+				domain: input?.domain ?? window.location.host
+			});
+			if (!authorizationResult.sign_in_result) throw new Error("Sign in failed, no sign in result returned by wallet");
+			const signedInAddress = authorizationResult.sign_in_result.address;
+			const signedInAccount = authorizationResult.accounts.find((acc) => acc.address == signedInAddress);
+			return {
+				account: {
+					...signedInAccount ?? { address: base58.encode(toUint8Array(signedInAddress)) },
+					publicKey: toUint8Array(signedInAddress),
+					chains: signedInAccount?.chains ?? this.#chains,
+					features: signedInAccount?.features ?? authorizationResult.capabilities.features
+				},
+				signedMessage: toUint8Array(authorizationResult.sign_in_result.signed_message),
+				signature: toUint8Array(authorizationResult.sign_in_result.signature)
+			};
+		} catch (e) {
+			throw new Error(getErrorMessage(e), { cause: e });
+		} finally {
+			this.#connecting = false;
+		}
+	};
+};
+//#endregion
+//#region src/createDefaultAuthorizationCache.ts
+const CACHE_KEY = "SolanaMobileWalletAdapterDefaultAuthorizationCache";
+function createDefaultAuthorizationCache() {
+	let storage;
+	try {
+		storage = window.localStorage;
+	} catch {}
+	return {
+		async clear() {
+			if (!storage) return;
+			try {
+				storage.removeItem(CACHE_KEY);
+			} catch {}
+		},
+		async get() {
+			if (!storage) return;
+			try {
+				const parsed = JSON.parse(storage.getItem(CACHE_KEY));
+				if (parsed && parsed.accounts) {
+					const parsedAccounts = parsed.accounts.map((account) => {
+						return {
+							...account,
+							publicKey: "publicKey" in account ? new Uint8Array(Object.values(account.publicKey)) : base58.decode(account.address)
+						};
+					});
+					return {
+						...parsed,
+						accounts: parsedAccounts
+					};
+				} else return parsed || void 0;
+			} catch {}
+		},
+		async set(authorization) {
+			if (!storage) return;
+			try {
+				storage.setItem(CACHE_KEY, JSON.stringify(authorization));
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region src/createDefaultChainSelector.ts
+function createDefaultChainSelector() {
+	return { async select(chains) {
+		if (chains.length === 1) return chains[0];
+		else if (chains.includes(SOLANA_MAINNET_CHAIN)) return SOLANA_MAINNET_CHAIN;
+		else return chains[0];
+	} };
+}
+
+export { LocalSolanaMobileWalletAdapterWallet, SolanaMobileWalletAdapterWalletName, createDefaultAuthorizationCache, createDefaultChainSelector };
+//# sourceMappingURL=index.browser-DaNhOhkQ.esm.js.map