{"version":3,"sources":["webpack:///./node_modules/@aws-amplify/ui-components/dist/esm-es5/auth-helpers-bd096ca7.js","webpack:///./node_modules/@aws-amplify/ui-components/dist/esm-es5/amplify-radio-button_2.entry.js"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","Symbol","iterator","this","n","v","op","TypeError","call","pop","length","push","logger","checkContact","user","handleAuthStateChange","data","newUser","error_1","_a","verifiedContact","Error","isCognitoUser","SignedIn","verified","unverified","Object","assign","VerifyContact","handleSignIn","username","password","error_2","signIn","debug","challengeName","SMSMFA","SoftwareTokenMFA","ConfirmSignIn","NewPasswordRequired","challengeParam","ResetPassword","MFASetup","TOTPSetup","CustomChallenge","trigger","CustomConfirmSignIn","code","ConfirmSignUp","ForgotPassword","message","EMPTY_PASSWORD","amplifyRadioButtonCss","AmplifyRadioButton","hostRef","placeholder","checked","disabled","prototype","render","class","type","name","onInput","handleInputChange","id","fieldId","inputProps","htmlFor","style","canPromise","toString","isarray","Array","isArray","arr","typedArraySupport","Uint8Array","__proto__","foo","Buffer","TYPED_ARRAY_SUPPORT","K_MAX_LENGTH","arg","offset","allocUnsafe","from","RangeError","isnan","val","createBuffer","that","buf","size","i","fromString","string","byteLength","actual","write","slice","fromArrayLike","array","fromArrayBuffer","byteOffset","undefined","fromObject","obj","isBuffer","len","copy","ArrayBuffer","buffer","utf8ToBytes","units","codePoint","Infinity","leadSurrogate","bytes","charCodeAt","isView","blitBuffer","src","dst","utf8Write","species","defineProperty","configurable","enumerable","writable","isFinite","remaining","start","end","newBuf","subarray","sliceLen","target","targetStart","set","fill","concat","list","pos","_isBuffer","b","toSJISFunction","alloc","from_1","typedarrayBuffer","CODEWORDS_COUNT","getSymbolSize","version","getSymbolTotalCodewords","getBCHDigit","digit","setToSJISFunction","isKanjiModeEnabled","toSJIS","kanji","utils","createCommonjsModule","fn","basedir","module","path","exports","require","base","commonjsRequire","errorCorrectionLevel","lcStr","toLowerCase","L","M","Q","H","bit","isValid","level","defaultValue","BitBuffer","get","index","bufIndex","Math","floor","put","num","putBit","getLengthInBits","bitBuffer","BitMatrix","reservedBit","row","col","reserved","xor","isReserved","bitMatrix","alignmentPattern","getRowColCoords","posCount","intervals","ceil","positions","reverse","getPositions","coords","posLength","j","getSymbolSize$1","FINDER_PATTERN_SIZE","finderPattern","maskPattern","Patterns","PATTERN000","PATTERN001","PATTERN010","PATTERN011","PATTERN100","PATTERN101","PATTERN110","PATTERN111","PenaltyScores","N1","N2","N3","N4","getMaskAt","mask","isNaN","parseInt","getPenaltyN1","points","sameCountCol","sameCountRow","lastCol","lastRow","getPenaltyN2","last","getPenaltyN3","bitsCol","bitsRow","getPenaltyN4","darkCount","modulesCount","k","abs","applyMask","pattern","getBestMask","setupFormatFunc","numPatterns","keys","bestPattern","lowerPenalty","p","penalty","EC_BLOCKS_TABLE","EC_CODEWORDS_TABLE","getBlocksCount","errorCorrectionLevel$1","getTotalCodewordsCount","errorCorrectionCode","EXP_TABLE","LOG_TABLE","x","log","exp","mul","galoisField","polynomial","p1","p2","coeff","mod","divident","divisor","generateECPolynomial","degree","poly","Buffer$1","ReedSolomonEncoder","genPoly","initialize","encode","pad","paddedData","remainder","buff","reedSolomonEncoder","versionCheck","numeric","alphanumeric","replace","byte","KANJI","RegExp","BYTE_KANJI","BYTE","NUMERIC","ALPHANUMERIC","TEST_KANJI","TEST_NUMERIC","TEST_ALPHANUMERIC","testKanji","str","test","testNumeric","testAlphanumeric","regex","mode","ccBits","MIXED","getCharCountIndicator","getBestModeForData","dataStr","G18","G18_BCH","getBestVersionForDataLength","currentVersion","getCapacity","getReservedBitsCount","mode$1","getTotalBitsFromDataArray","segments","totalBits","forEach","reservedBits","getBitsLength","getBestVersionForMixedData","totalCodewords","ecTotalCodewords","dataTotalCodewordsBits","usableBits","getBestVersionForData","seg","ecl","getLength","getEncodedBits","d","G15","G15_MASK","G15_BCH","formatInfo","NumericData","group","substr","remainingNum","numericData","ALPHA_NUM_CHARS","AlphanumericData","indexOf","alphanumericData","ByteData","l","byteData","KanjiData","kanjiData","dijkstra_1","dijkstra","single_source_shortest_paths","graph","s","predecessors","costs","closest","u","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","open","PriorityQueue","make","empty","cost","hasOwnProperty","msg","join","extract_shortest_path_from_predecessor_list","nodes","find_path","opts","key","T","queue","sorter","default_sorter","a","item","sort","shift","getStringByteLength","unescape","encodeURIComponent","getSegments","exec","getSegmentsFromString","byteSegs","kanjiSegs","numSegs","alphaNumSegs","segs","s1","s2","map","getSegmentBitsLength","mergeSegments","reduce","acc","curr","prevSeg","buildNodes","buildGraph","table","prevNodeIds","nodeGroup","currentNodeIds","node","lastCount","prevNodeId","buildSingleSegment","modesHint","bestMode","fromArray","optimizedSegs","rawSplit","setupFinderPattern","matrix","r","c","setupTimingPattern","setupAlignmentPattern","setupVersionInfo","version$1","bits","setupFormatInfo","setupData","inc","bitIndex","byteIndex","dark","createData","remainingByte","createCodewords","dataTotalCodewords","ecTotalBlocks","blocksInGroup2","blocksInGroup1","totalCodewordsInGroup1","dataCodewordsInGroup1","dataCodewordsInGroup2","ecCount","rs","dcData","ecData","maxDataSize","dataSize","max","createSymbol","maskPattern$1","segments$1","estimatedVersion","rawSegments","bestVersion","dataBits","moduleCount","modules","bind","create","options","toSJISFunc","qrcode","utils$1","hex2rgba","hex","hexCode","split","hexValue","getOptions","color","margin","width","scale","light","rendererOpts","getScale","qrSize","getImageWidth","qrToImageData","imgData","qr","symbolSize","scaledMargin","palette","posDst","pxColor","iSrc","jSrc","canvas","clearCanvas","ctx","clearRect","height","getCanvasElement","document","createElement","qrData","canvasEl","getContext","image","createImageData","putImageData","renderToDataURL","toDataURL","quality","getColorAttrib","attrib","alpha","toFixed","svgCmd","cmd","qrToPath","moveBy","newRow","lineLength","cb","qrcodesize","bg","viewBox","svgTag","renderCanvas","renderFunc","text","args","arguments","argsNum","isLastArgCb","create$1","toCanvas","toString_1","browser","amplifyTotpSetupCss","AmplifyTOTPSetup","class_1","autoFocus","headerText","TOTP_HEADER_TEXT","issuer","TOTP_ISSUER","setupMessage","qrCodeInput","loading","componentWillLoad","_this","removeHubListener","authState","setup","disconnectedCallback","buildOtpAuthPath","secretKey","onTOTPEvent","event","handleTotpInputChange","generateQRCode","codeFromTotp","_b","qrCodeImageSource","encodedIssuer","encodeURI","setupTOTP","TOTP_SETUP_FAILURE","verifyTotpToken","error_3","preventDefault","setPreferredMFA","TOTP","TOTP_SUCCESS_MESSAGE","error","submitButtonText","TOTP_SUBMIT_BUTTON_TEXT","handleSubmit","alt","QR_CODE_ALT","TOTP_LABEL"],"mappings":"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","file":"js/chunk-e7071c50.41e030df.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport { Logger, isEmpty } from '@aws-amplify/core';\nimport { A as AuthState, C as ChallengeName } from './auth-types-78df304e.js';\nimport { Auth, CognitoUser } from '@aws-amplify/auth';\nimport { T as Translations } from './Translations-c833f663.js';\nimport { N as NO_AUTH_MODULE_FOUND } from './constants-d1abe7de.js';\nimport { a as dispatchToastHubEvent } from './helpers-4f61e5ff.js';\nvar logger = new Logger('auth-helpers');\nfunction checkContact(user, handleAuthStateChange) {\n    return __awaiter(this, void 0, void 0, function () {\n        var data, newUser, error_1;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    if (!Auth || typeof Auth.verifiedContact !== 'function') {\n                        throw new Error(NO_AUTH_MODULE_FOUND);\n                    }\n                    // If `user` is a federated user, we shouldn't call `verifiedContact`\n                    // since `user` isn't `CognitoUser`\n                    if (!isCognitoUser(user)) {\n                        handleAuthStateChange(AuthState.SignedIn, user);\n                        return [2 /*return*/];\n                    }\n                    _a.label = 1;\n                case 1:\n                    _a.trys.push([1, 3, , 4]);\n                    return [4 /*yield*/, Auth.verifiedContact(user)];\n                case 2:\n                    data = _a.sent();\n                    if (!isEmpty(data.verified) || isEmpty(data.unverified)) {\n                        handleAuthStateChange(AuthState.SignedIn, user);\n                    }\n                    else {\n                        newUser = Object.assign(user, data);\n                        handleAuthStateChange(AuthState.VerifyContact, newUser);\n                    }\n                    return [3 /*break*/, 4];\n                case 3:\n                    error_1 = _a.sent();\n                    dispatchToastHubEvent(error_1);\n                    return [3 /*break*/, 4];\n                case 4: return [2 /*return*/];\n            }\n        });\n    });\n}\nvar handleSignIn = function (username, password, handleAuthStateChange) { return __awaiter(void 0, void 0, void 0, function () {\n    var user, error_2;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0:\n                if (!Auth || typeof Auth.signIn !== 'function') {\n                    throw new Error(NO_AUTH_MODULE_FOUND);\n                }\n                _a.label = 1;\n            case 1:\n                _a.trys.push([1, 9, , 10]);\n                return [4 /*yield*/, Auth.signIn(username, password)];\n            case 2:\n                user = _a.sent();\n                logger.debug(user);\n                if (!(user.challengeName === ChallengeName.SMSMFA || user.challengeName === ChallengeName.SoftwareTokenMFA)) return [3 /*break*/, 3];\n                logger.debug('confirm user with ' + user.challengeName);\n                handleAuthStateChange(AuthState.ConfirmSignIn, user);\n                return [3 /*break*/, 8];\n            case 3:\n                if (!(user.challengeName === ChallengeName.NewPasswordRequired)) return [3 /*break*/, 4];\n                logger.debug('require new password', user.challengeParam);\n                handleAuthStateChange(AuthState.ResetPassword, user);\n                return [3 /*break*/, 8];\n            case 4:\n                if (!(user.challengeName === ChallengeName.MFASetup)) return [3 /*break*/, 5];\n                logger.debug('TOTP setup', user.challengeParam);\n                handleAuthStateChange(AuthState.TOTPSetup, user);\n                return [3 /*break*/, 8];\n            case 5:\n                if (!(user.challengeName === ChallengeName.CustomChallenge &&\n                    user.challengeParam &&\n                    user.challengeParam.trigger === 'true')) return [3 /*break*/, 6];\n                logger.debug('custom challenge', user.challengeParam);\n                handleAuthStateChange(AuthState.CustomConfirmSignIn, user);\n                return [3 /*break*/, 8];\n            case 6: return [4 /*yield*/, checkContact(user, handleAuthStateChange)];\n            case 7:\n                _a.sent();\n                _a.label = 8;\n            case 8: return [3 /*break*/, 10];\n            case 9:\n                error_2 = _a.sent();\n                if (error_2.code === 'UserNotConfirmedException') {\n                    logger.debug('the user is not confirmed');\n                    handleAuthStateChange(AuthState.ConfirmSignUp, { username: username });\n                }\n                else if (error_2.code === 'PasswordResetRequiredException') {\n                    logger.debug('the user requires a new password');\n                    handleAuthStateChange(AuthState.ForgotPassword, { username: username });\n                }\n                else if (error_2.code === 'InvalidParameterException' && password === '') {\n                    logger.debug('Password cannot be empty');\n                    error_2.message = Translations.EMPTY_PASSWORD;\n                }\n                dispatchToastHubEvent(error_2);\n                return [3 /*break*/, 10];\n            case 10: return [2 /*return*/];\n        }\n    });\n}); };\nvar isCognitoUser = function (user) {\n    return user instanceof CognitoUser;\n};\nexport { checkContact as c, handleSignIn as h };\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport { r as registerInstance, h, H as Host } from './index-3fb5c139.js';\nimport { Logger, I18n } from '@aws-amplify/core';\nimport { M as MfaOption, A as AuthState } from './auth-types-78df304e.js';\nimport { Auth } from '@aws-amplify/auth';\nimport { T as Translations } from './Translations-c833f663.js';\nimport { S as SETUP_TOTP, i as SUCCESS, N as NO_AUTH_MODULE_FOUND } from './constants-d1abe7de.js';\nimport { d as dispatchAuthStateChangeEvent, o as onAuthUIStateChange, a as dispatchToastHubEvent } from './helpers-4f61e5ff.js';\nimport { c as checkContact } from './auth-helpers-bd096ca7.js';\nimport buffer from 'buffer';\nvar amplifyRadioButtonCss = \":host{--font-family:var(--amplify-font-family)}.radio-button{display:block;width:100%;padding:16px;font-size:var(--amplify-text-sm);font-family:var(--font-family)}.radio-button input{margin-right:12px}\";\nvar AmplifyRadioButton = /** @class */ (function () {\n    function AmplifyRadioButton(hostRef) {\n        registerInstance(this, hostRef);\n        /** (Optional) The placeholder for the input element.  Using hints is recommended, but placeholders can also be useful to convey information to users. */\n        this.placeholder = '';\n        /** If `true`, the radio button is selected. */\n        this.checked = false;\n        /** If `true`, the checkbox is disabled */\n        this.disabled = false;\n    }\n    AmplifyRadioButton.prototype.render = function () {\n        return (h(\"span\", { class: \"radio-button\" }, h(\"input\", Object.assign({ type: \"radio\", name: this.name, value: this.value, onInput: this.handleInputChange, placeholder: this.placeholder, id: this.fieldId, checked: this.checked, disabled: this.disabled }, this.inputProps)), h(\"amplify-label\", { htmlFor: this.fieldId }, this.label)));\n    };\n    return AmplifyRadioButton;\n}());\nAmplifyRadioButton.style = amplifyRadioButtonCss;\n// can-promise has a crash in some versions of react native that dont have\n// standard global objects\n// https://github.com/soldair/node-qrcode/issues/157\nvar canPromise = function () {\n    return typeof Promise === 'function' && Promise.prototype && Promise.prototype.then;\n};\nvar toString = {}.toString;\nvar isarray = Array.isArray || function (arr) {\n    return toString.call(arr) == '[object Array]';\n};\nfunction typedArraySupport() {\n    // Can typed array instances be augmented?\n    try {\n        var arr = new Uint8Array(1);\n        arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42; } };\n        return arr.foo() === 42;\n    }\n    catch (e) {\n        return false;\n    }\n}\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport();\nvar K_MAX_LENGTH = Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff;\nfunction Buffer(arg, offset, length) {\n    if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n        return new Buffer(arg, offset, length);\n    }\n    if (typeof arg === 'number') {\n        return allocUnsafe(this, arg);\n    }\n    return from(this, arg, offset, length);\n}\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n    Buffer.prototype.__proto__ = Uint8Array.prototype;\n    Buffer.__proto__ = Uint8Array;\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    if (typeof Symbol !== 'undefined' && Symbol.species &&\n        Buffer[Symbol.species] === Buffer) {\n        Object.defineProperty(Buffer, Symbol.species, {\n            value: null,\n            configurable: true,\n            enumerable: false,\n            writable: false\n        });\n    }\n}\nfunction checked(length) {\n    // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n    // length is NaN (which is otherwise coerced to zero.)\n    if (length >= K_MAX_LENGTH) {\n        throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n            'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes');\n    }\n    return length | 0;\n}\nfunction isnan(val) {\n    return val !== val; // eslint-disable-line no-self-compare\n}\nfunction createBuffer(that, length) {\n    var buf;\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n        buf = new Uint8Array(length);\n        buf.__proto__ = Buffer.prototype;\n    }\n    else {\n        // Fallback: Return an object instance of the Buffer class\n        buf = that;\n        if (buf === null) {\n            buf = new Buffer(length);\n        }\n        buf.length = length;\n    }\n    return buf;\n}\nfunction allocUnsafe(that, size) {\n    var buf = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n    if (!Buffer.TYPED_ARRAY_SUPPORT) {\n        for (var i = 0; i < size; ++i) {\n            buf[i] = 0;\n        }\n    }\n    return buf;\n}\nfunction fromString(that, string) {\n    var length = byteLength(string) | 0;\n    var buf = createBuffer(that, length);\n    var actual = buf.write(string);\n    if (actual !== length) {\n        // Writing a hex string, for example, that contains invalid characters will\n        // cause everything after the first invalid character to be ignored. (e.g.\n        // 'abxxcd' will be treated as 'ab')\n        buf = buf.slice(0, actual);\n    }\n    return buf;\n}\nfunction fromArrayLike(that, array) {\n    var length = array.length < 0 ? 0 : checked(array.length) | 0;\n    var buf = createBuffer(that, length);\n    for (var i = 0; i < length; i += 1) {\n        buf[i] = array[i] & 255;\n    }\n    return buf;\n}\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n    if (byteOffset < 0 || array.byteLength < byteOffset) {\n        throw new RangeError('\\'offset\\' is out of bounds');\n    }\n    if (array.byteLength < byteOffset + (length || 0)) {\n        throw new RangeError('\\'length\\' is out of bounds');\n    }\n    var buf;\n    if (byteOffset === undefined && length === undefined) {\n        buf = new Uint8Array(array);\n    }\n    else if (length === undefined) {\n        buf = new Uint8Array(array, byteOffset);\n    }\n    else {\n        buf = new Uint8Array(array, byteOffset, length);\n    }\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n        // Return an augmented `Uint8Array` instance, for best performance\n        buf.__proto__ = Buffer.prototype;\n    }\n    else {\n        // Fallback: Return an object instance of the Buffer class\n        buf = fromArrayLike(that, buf);\n    }\n    return buf;\n}\nfunction fromObject(that, obj) {\n    if (Buffer.isBuffer(obj)) {\n        var len = checked(obj.length) | 0;\n        var buf = createBuffer(that, len);\n        if (buf.length === 0) {\n            return buf;\n        }\n        obj.copy(buf, 0, 0, len);\n        return buf;\n    }\n    if (obj) {\n        if ((typeof ArrayBuffer !== 'undefined' &&\n            obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n            if (typeof obj.length !== 'number' || isnan(obj.length)) {\n                return createBuffer(that, 0);\n            }\n            return fromArrayLike(that, obj);\n        }\n        if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n            return fromArrayLike(that, obj.data);\n        }\n    }\n    throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\nfunction utf8ToBytes(string, units) {\n    units = units || Infinity;\n    var codePoint;\n    var length = string.length;\n    var leadSurrogate = null;\n    var bytes = [];\n    for (var i = 0; i < length; ++i) {\n        codePoint = string.charCodeAt(i);\n        // is surrogate component\n        if (codePoint > 0xD7FF && codePoint < 0xE000) {\n            // last char was a lead\n            if (!leadSurrogate) {\n                // no lead yet\n                if (codePoint > 0xDBFF) {\n                    // unexpected trail\n                    if ((units -= 3) > -1)\n                        bytes.push(0xEF, 0xBF, 0xBD);\n                    continue;\n                }\n                else if (i + 1 === length) {\n                    // unpaired lead\n                    if ((units -= 3) > -1)\n                        bytes.push(0xEF, 0xBF, 0xBD);\n                    continue;\n                }\n                // valid lead\n                leadSurrogate = codePoint;\n                continue;\n            }\n            // 2 leads in a row\n            if (codePoint < 0xDC00) {\n                if ((units -= 3) > -1)\n                    bytes.push(0xEF, 0xBF, 0xBD);\n                leadSurrogate = codePoint;\n                continue;\n            }\n            // valid surrogate pair\n            codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n        }\n        else if (leadSurrogate) {\n            // valid bmp char, but last char was a lead\n            if ((units -= 3) > -1)\n                bytes.push(0xEF, 0xBF, 0xBD);\n        }\n        leadSurrogate = null;\n        // encode utf8\n        if (codePoint < 0x80) {\n            if ((units -= 1) < 0)\n                break;\n            bytes.push(codePoint);\n        }\n        else if (codePoint < 0x800) {\n            if ((units -= 2) < 0)\n                break;\n            bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n        }\n        else if (codePoint < 0x10000) {\n            if ((units -= 3) < 0)\n                break;\n            bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n        }\n        else if (codePoint < 0x110000) {\n            if ((units -= 4) < 0)\n                break;\n            bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n        }\n        else {\n            throw new Error('Invalid code point');\n        }\n    }\n    return bytes;\n}\nfunction byteLength(string) {\n    if (Buffer.isBuffer(string)) {\n        return string.length;\n    }\n    if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n        (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n        return string.byteLength;\n    }\n    if (typeof string !== 'string') {\n        string = '' + string;\n    }\n    var len = string.length;\n    if (len === 0)\n        return 0;\n    return utf8ToBytes(string).length;\n}\nfunction blitBuffer(src, dst, offset, length) {\n    for (var i = 0; i < length; ++i) {\n        if ((i + offset >= dst.length) || (i >= src.length))\n            break;\n        dst[i + offset] = src[i];\n    }\n    return i;\n}\nfunction utf8Write(buf, string, offset, length) {\n    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\nfunction from(that, value, offset, length) {\n    if (typeof value === 'number') {\n        throw new TypeError('\"value\" argument must not be a number');\n    }\n    if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n        return fromArrayBuffer(that, value, offset, length);\n    }\n    if (typeof value === 'string') {\n        return fromString(that, value);\n    }\n    return fromObject(that, value);\n}\nBuffer.prototype.write = function write(string, offset, length) {\n    // Buffer#write(string)\n    if (offset === undefined) {\n        length = this.length;\n        offset = 0;\n        // Buffer#write(string, encoding)\n    }\n    else if (length === undefined && typeof offset === 'string') {\n        length = this.length;\n        offset = 0;\n        // Buffer#write(string, offset[, length])\n    }\n    else if (isFinite(offset)) {\n        offset = offset | 0;\n        if (isFinite(length)) {\n            length = length | 0;\n        }\n        else {\n            length = undefined;\n        }\n    }\n    var remaining = this.length - offset;\n    if (length === undefined || length > remaining)\n        length = remaining;\n    if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n        throw new RangeError('Attempt to write outside buffer bounds');\n    }\n    return utf8Write(this, string, offset, length);\n};\nBuffer.prototype.slice = function slice(start, end) {\n    var len = this.length;\n    start = ~~start;\n    end = end === undefined ? len : ~~end;\n    if (start < 0) {\n        start += len;\n        if (start < 0)\n            start = 0;\n    }\n    else if (start > len) {\n        start = len;\n    }\n    if (end < 0) {\n        end += len;\n        if (end < 0)\n            end = 0;\n    }\n    else if (end > len) {\n        end = len;\n    }\n    if (end < start)\n        end = start;\n    var newBuf;\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n        newBuf = this.subarray(start, end);\n        // Return an augmented `Uint8Array` instance\n        newBuf.__proto__ = Buffer.prototype;\n    }\n    else {\n        var sliceLen = end - start;\n        newBuf = new Buffer(sliceLen, undefined);\n        for (var i = 0; i < sliceLen; ++i) {\n            newBuf[i] = this[i + start];\n        }\n    }\n    return newBuf;\n};\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n    if (!start)\n        start = 0;\n    if (!end && end !== 0)\n        end = this.length;\n    if (targetStart >= target.length)\n        targetStart = target.length;\n    if (!targetStart)\n        targetStart = 0;\n    if (end > 0 && end < start)\n        end = start;\n    // Copy 0 bytes; we're done\n    if (end === start)\n        return 0;\n    if (target.length === 0 || this.length === 0)\n        return 0;\n    // Fatal error conditions\n    if (targetStart < 0) {\n        throw new RangeError('targetStart out of bounds');\n    }\n    if (start < 0 || start >= this.length)\n        throw new RangeError('sourceStart out of bounds');\n    if (end < 0)\n        throw new RangeError('sourceEnd out of bounds');\n    // Are we oob?\n    if (end > this.length)\n        end = this.length;\n    if (target.length - targetStart < end - start) {\n        end = target.length - targetStart + start;\n    }\n    var len = end - start;\n    var i;\n    if (this === target && start < targetStart && targetStart < end) {\n        // descending copy from end\n        for (i = len - 1; i >= 0; --i) {\n            target[i + targetStart] = this[i + start];\n        }\n    }\n    else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n        // ascending copy from start\n        for (i = 0; i < len; ++i) {\n            target[i + targetStart] = this[i + start];\n        }\n    }\n    else {\n        Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n    }\n    return len;\n};\nBuffer.prototype.fill = function fill(val, start, end) {\n    // Handle string cases:\n    if (typeof val === 'string') {\n        if (typeof start === 'string') {\n            start = 0;\n            end = this.length;\n        }\n        else if (typeof end === 'string') {\n            end = this.length;\n        }\n        if (val.length === 1) {\n            var code = val.charCodeAt(0);\n            if (code < 256) {\n                val = code;\n            }\n        }\n    }\n    else if (typeof val === 'number') {\n        val = val & 255;\n    }\n    // Invalid ranges are not set to a default, so can range check early.\n    if (start < 0 || this.length < start || this.length < end) {\n        throw new RangeError('Out of range index');\n    }\n    if (end <= start) {\n        return this;\n    }\n    start = start >>> 0;\n    end = end === undefined ? this.length : end >>> 0;\n    if (!val)\n        val = 0;\n    var i;\n    if (typeof val === 'number') {\n        for (i = start; i < end; ++i) {\n            this[i] = val;\n        }\n    }\n    else {\n        var bytes = Buffer.isBuffer(val)\n            ? val\n            : new Buffer(val);\n        var len = bytes.length;\n        for (i = 0; i < end - start; ++i) {\n            this[i + start] = bytes[i % len];\n        }\n    }\n    return this;\n};\nBuffer.concat = function concat(list, length) {\n    if (!isarray(list)) {\n        throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n    if (list.length === 0) {\n        return createBuffer(null, 0);\n    }\n    var i;\n    if (length === undefined) {\n        length = 0;\n        for (i = 0; i < list.length; ++i) {\n            length += list[i].length;\n        }\n    }\n    var buffer = allocUnsafe(null, length);\n    var pos = 0;\n    for (i = 0; i < list.length; ++i) {\n        var buf = list[i];\n        if (!Buffer.isBuffer(buf)) {\n            throw new TypeError('\"list\" argument must be an Array of Buffers');\n        }\n        buf.copy(buffer, pos);\n        pos += buf.length;\n    }\n    return buffer;\n};\nBuffer.byteLength = byteLength;\nBuffer.prototype._isBuffer = true;\nBuffer.isBuffer = function isBuffer(b) {\n    return !!(b != null && b._isBuffer);\n};\nvar alloc = function (size) {\n    var buffer = new Buffer(size);\n    buffer.fill(0);\n    return buffer;\n};\nvar from_1 = function (data) {\n    return new Buffer(data);\n};\nvar typedarrayBuffer = {\n    alloc: alloc,\n    from: from_1\n};\nvar toSJISFunction;\nvar CODEWORDS_COUNT = [\n    0,\n    26, 44, 70, 100, 134, 172, 196, 242, 292, 346,\n    404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,\n    1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,\n    2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706\n];\n/**\n * Returns the QR Code size for the specified version\n *\n * @param  {Number} version QR Code version\n * @return {Number}         size of QR code\n */\nvar getSymbolSize = function getSymbolSize(version) {\n    if (!version)\n        throw new Error('\"version\" cannot be null or undefined');\n    if (version < 1 || version > 40)\n        throw new Error('\"version\" should be in range from 1 to 40');\n    return version * 4 + 17;\n};\n/**\n * Returns the total number of codewords used to store data and EC information.\n *\n * @param  {Number} version QR Code version\n * @return {Number}         Data length in bits\n */\nvar getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {\n    return CODEWORDS_COUNT[version];\n};\n/**\n * Encode data with Bose-Chaudhuri-Hocquenghem\n *\n * @param  {Number} data Value to encode\n * @return {Number}      Encoded value\n */\nvar getBCHDigit = function (data) {\n    var digit = 0;\n    while (data !== 0) {\n        digit++;\n        data >>>= 1;\n    }\n    return digit;\n};\nvar setToSJISFunction = function setToSJISFunction(f) {\n    if (typeof f !== 'function') {\n        throw new Error('\"toSJISFunc\" is not a valid function.');\n    }\n    toSJISFunction = f;\n};\nvar isKanjiModeEnabled = function () {\n    return typeof toSJISFunction !== 'undefined';\n};\nvar toSJIS = function toSJIS(kanji) {\n    return toSJISFunction(kanji);\n};\nvar utils = {\n    getSymbolSize: getSymbolSize,\n    getSymbolTotalCodewords: getSymbolTotalCodewords,\n    getBCHDigit: getBCHDigit,\n    setToSJISFunction: setToSJISFunction,\n    isKanjiModeEnabled: isKanjiModeEnabled,\n    toSJIS: toSJIS\n};\nfunction createCommonjsModule(fn, basedir, module) {\n    return module = {\n        path: basedir,\n        exports: {},\n        require: function (path, base) {\n            return commonjsRequire();\n        }\n    }, fn(module, module.exports), module.exports;\n}\nfunction commonjsRequire() {\n    throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');\n}\nvar errorCorrectionLevel = createCommonjsModule(function (module, exports) {\n    exports.L = { bit: 1 };\n    exports.M = { bit: 0 };\n    exports.Q = { bit: 3 };\n    exports.H = { bit: 2 };\n    function fromString(string) {\n        if (typeof string !== 'string') {\n            throw new Error('Param is not a string');\n        }\n        var lcStr = string.toLowerCase();\n        switch (lcStr) {\n            case 'l':\n            case 'low':\n                return exports.L;\n            case 'm':\n            case 'medium':\n                return exports.M;\n            case 'q':\n            case 'quartile':\n                return exports.Q;\n            case 'h':\n            case 'high':\n                return exports.H;\n            default:\n                throw new Error('Unknown EC Level: ' + string);\n        }\n    }\n    exports.isValid = function isValid(level) {\n        return level && typeof level.bit !== 'undefined' &&\n            level.bit >= 0 && level.bit < 4;\n    };\n    exports.from = function from(value, defaultValue) {\n        if (exports.isValid(value)) {\n            return value;\n        }\n        try {\n            return fromString(value);\n        }\n        catch (e) {\n            return defaultValue;\n        }\n    };\n});\nfunction BitBuffer() {\n    this.buffer = [];\n    this.length = 0;\n}\nBitBuffer.prototype = {\n    get: function (index) {\n        var bufIndex = Math.floor(index / 8);\n        return ((this.buffer[bufIndex] >>> (7 - index % 8)) & 1) === 1;\n    },\n    put: function (num, length) {\n        for (var i = 0; i < length; i++) {\n            this.putBit(((num >>> (length - i - 1)) & 1) === 1);\n        }\n    },\n    getLengthInBits: function () {\n        return this.length;\n    },\n    putBit: function (bit) {\n        var bufIndex = Math.floor(this.length / 8);\n        if (this.buffer.length <= bufIndex) {\n            this.buffer.push(0);\n        }\n        if (bit) {\n            this.buffer[bufIndex] |= (0x80 >>> (this.length % 8));\n        }\n        this.length++;\n    }\n};\nvar bitBuffer = BitBuffer;\n/**\n * Helper class to handle QR Code symbol modules\n *\n * @param {Number} size Symbol size\n */\nfunction BitMatrix(size) {\n    if (!size || size < 1) {\n        throw new Error('BitMatrix size must be defined and greater than 0');\n    }\n    this.size = size;\n    this.data = typedarrayBuffer.alloc(size * size);\n    this.reservedBit = typedarrayBuffer.alloc(size * size);\n}\n/**\n * Set bit value at specified location\n * If reserved flag is set, this bit will be ignored during masking process\n *\n * @param {Number}  row\n * @param {Number}  col\n * @param {Boolean} value\n * @param {Boolean} reserved\n */\nBitMatrix.prototype.set = function (row, col, value, reserved) {\n    var index = row * this.size + col;\n    this.data[index] = value;\n    if (reserved)\n        this.reservedBit[index] = true;\n};\n/**\n * Returns bit value at specified location\n *\n * @param  {Number}  row\n * @param  {Number}  col\n * @return {Boolean}\n */\nBitMatrix.prototype.get = function (row, col) {\n    return this.data[row * this.size + col];\n};\n/**\n * Applies xor operator at specified location\n * (used during masking process)\n *\n * @param {Number}  row\n * @param {Number}  col\n * @param {Boolean} value\n */\nBitMatrix.prototype.xor = function (row, col, value) {\n    this.data[row * this.size + col] ^= value;\n};\n/**\n * Check if bit at specified location is reserved\n *\n * @param {Number}   row\n * @param {Number}   col\n * @return {Boolean}\n */\nBitMatrix.prototype.isReserved = function (row, col) {\n    return this.reservedBit[row * this.size + col];\n};\nvar bitMatrix = BitMatrix;\nvar alignmentPattern = createCommonjsModule(function (module, exports) {\n    /**\n     * Alignment pattern are fixed reference pattern in defined positions\n     * in a matrix symbology, which enables the decode software to re-synchronise\n     * the coordinate mapping of the image modules in the event of moderate amounts\n     * of distortion of the image.\n     *\n     * Alignment patterns are present only in QR Code symbols of version 2 or larger\n     * and their number depends on the symbol version.\n     */\n    var getSymbolSize = utils.getSymbolSize;\n    /**\n     * Calculate the row/column coordinates of the center module of each alignment pattern\n     * for the specified QR Code version.\n     *\n     * The alignment patterns are positioned symmetrically on either side of the diagonal\n     * running from the top left corner of the symbol to the bottom right corner.\n     *\n     * Since positions are simmetrical only half of the coordinates are returned.\n     * Each item of the array will represent in turn the x and y coordinate.\n     * @see {@link getPositions}\n     *\n     * @param  {Number} version QR Code version\n     * @return {Array}          Array of coordinate\n     */\n    exports.getRowColCoords = function getRowColCoords(version) {\n        if (version === 1)\n            return [];\n        var posCount = Math.floor(version / 7) + 2;\n        var size = getSymbolSize(version);\n        var intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;\n        var positions = [size - 7]; // Last coord is always (size - 7)\n        for (var i = 1; i < posCount - 1; i++) {\n            positions[i] = positions[i - 1] - intervals;\n        }\n        positions.push(6); // First coord is always 6\n        return positions.reverse();\n    };\n    /**\n     * Returns an array containing the positions of each alignment pattern.\n     * Each array's element represent the center point of the pattern as (x, y) coordinates\n     *\n     * Coordinates are calculated expanding the row/column coordinates returned by {@link getRowColCoords}\n     * and filtering out the items that overlaps with finder pattern\n     *\n     * @example\n     * For a Version 7 symbol {@link getRowColCoords} returns values 6, 22 and 38.\n     * The alignment patterns, therefore, are to be centered on (row, column)\n     * positions (6,22), (22,6), (22,22), (22,38), (38,22), (38,38).\n     * Note that the coordinates (6,6), (6,38), (38,6) are occupied by finder patterns\n     * and are not therefore used for alignment patterns.\n     *\n     * var pos = getPositions(7)\n     * // [[6,22], [22,6], [22,22], [22,38], [38,22], [38,38]]\n     *\n     * @param  {Number} version QR Code version\n     * @return {Array}          Array of coordinates\n     */\n    exports.getPositions = function getPositions(version) {\n        var coords = [];\n        var pos = exports.getRowColCoords(version);\n        var posLength = pos.length;\n        for (var i = 0; i < posLength; i++) {\n            for (var j = 0; j < posLength; j++) {\n                // Skip if position is occupied by finder patterns\n                if ((i === 0 && j === 0) || // top-left\n                    (i === 0 && j === posLength - 1) || // bottom-left\n                    (i === posLength - 1 && j === 0)) { // top-right\n                    continue;\n                }\n                coords.push([pos[i], pos[j]]);\n            }\n        }\n        return coords;\n    };\n});\nvar getSymbolSize$1 = utils.getSymbolSize;\nvar FINDER_PATTERN_SIZE = 7;\n/**\n * Returns an array containing the positions of each finder pattern.\n * Each array's element represent the top-left point of the pattern as (x, y) coordinates\n *\n * @param  {Number} version QR Code version\n * @return {Array}          Array of coordinates\n */\nvar getPositions = function getPositions(version) {\n    var size = getSymbolSize$1(version);\n    return [\n        // top-left\n        [0, 0],\n        // top-right\n        [size - FINDER_PATTERN_SIZE, 0],\n        // bottom-left\n        [0, size - FINDER_PATTERN_SIZE]\n    ];\n};\nvar finderPattern = {\n    getPositions: getPositions\n};\nvar maskPattern = createCommonjsModule(function (module, exports) {\n    /**\n     * Data mask pattern reference\n     * @type {Object}\n     */\n    exports.Patterns = {\n        PATTERN000: 0,\n        PATTERN001: 1,\n        PATTERN010: 2,\n        PATTERN011: 3,\n        PATTERN100: 4,\n        PATTERN101: 5,\n        PATTERN110: 6,\n        PATTERN111: 7\n    };\n    /**\n     * Weighted penalty scores for the undesirable features\n     * @type {Object}\n     */\n    var PenaltyScores = {\n        N1: 3,\n        N2: 3,\n        N3: 40,\n        N4: 10\n    };\n    /**\n     * Check if mask pattern value is valid\n     *\n     * @param  {Number}  mask    Mask pattern\n     * @return {Boolean}         true if valid, false otherwise\n     */\n    exports.isValid = function isValid(mask) {\n        return mask != null && mask !== '' && !isNaN(mask) && mask >= 0 && mask <= 7;\n    };\n    /**\n     * Returns mask pattern from a value.\n     * If value is not valid, returns undefined\n     *\n     * @param  {Number|String} value        Mask pattern value\n     * @return {Number}                     Valid mask pattern or undefined\n     */\n    exports.from = function from(value) {\n        return exports.isValid(value) ? parseInt(value, 10) : undefined;\n    };\n    /**\n    * Find adjacent modules in row/column with the same color\n    * and assign a penalty value.\n    *\n    * Points: N1 + i\n    * i is the amount by which the number of adjacent modules of the same color exceeds 5\n    */\n    exports.getPenaltyN1 = function getPenaltyN1(data) {\n        var size = data.size;\n        var points = 0;\n        var sameCountCol = 0;\n        var sameCountRow = 0;\n        var lastCol = null;\n        var lastRow = null;\n        for (var row = 0; row < size; row++) {\n            sameCountCol = sameCountRow = 0;\n            lastCol = lastRow = null;\n            for (var col = 0; col < size; col++) {\n                var module = data.get(row, col);\n                if (module === lastCol) {\n                    sameCountCol++;\n                }\n                else {\n                    if (sameCountCol >= 5)\n                        points += PenaltyScores.N1 + (sameCountCol - 5);\n                    lastCol = module;\n                    sameCountCol = 1;\n                }\n                module = data.get(col, row);\n                if (module === lastRow) {\n                    sameCountRow++;\n                }\n                else {\n                    if (sameCountRow >= 5)\n                        points += PenaltyScores.N1 + (sameCountRow - 5);\n                    lastRow = module;\n                    sameCountRow = 1;\n                }\n            }\n            if (sameCountCol >= 5)\n                points += PenaltyScores.N1 + (sameCountCol - 5);\n            if (sameCountRow >= 5)\n                points += PenaltyScores.N1 + (sameCountRow - 5);\n        }\n        return points;\n    };\n    /**\n     * Find 2x2 blocks with the same color and assign a penalty value\n     *\n     * Points: N2 * (m - 1) * (n - 1)\n     */\n    exports.getPenaltyN2 = function getPenaltyN2(data) {\n        var size = data.size;\n        var points = 0;\n        for (var row = 0; row < size - 1; row++) {\n            for (var col = 0; col < size - 1; col++) {\n                var last = data.get(row, col) +\n                    data.get(row, col + 1) +\n                    data.get(row + 1, col) +\n                    data.get(row + 1, col + 1);\n                if (last === 4 || last === 0)\n                    points++;\n            }\n        }\n        return points * PenaltyScores.N2;\n    };\n    /**\n     * Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,\n     * preceded or followed by light area 4 modules wide\n     *\n     * Points: N3 * number of pattern found\n     */\n    exports.getPenaltyN3 = function getPenaltyN3(data) {\n        var size = data.size;\n        var points = 0;\n        var bitsCol = 0;\n        var bitsRow = 0;\n        for (var row = 0; row < size; row++) {\n            bitsCol = bitsRow = 0;\n            for (var col = 0; col < size; col++) {\n                bitsCol = ((bitsCol << 1) & 0x7FF) | data.get(row, col);\n                if (col >= 10 && (bitsCol === 0x5D0 || bitsCol === 0x05D))\n                    points++;\n                bitsRow = ((bitsRow << 1) & 0x7FF) | data.get(col, row);\n                if (col >= 10 && (bitsRow === 0x5D0 || bitsRow === 0x05D))\n                    points++;\n            }\n        }\n        return points * PenaltyScores.N3;\n    };\n    /**\n     * Calculate proportion of dark modules in entire symbol\n     *\n     * Points: N4 * k\n     *\n     * k is the rating of the deviation of the proportion of dark modules\n     * in the symbol from 50% in steps of 5%\n     */\n    exports.getPenaltyN4 = function getPenaltyN4(data) {\n        var darkCount = 0;\n        var modulesCount = data.data.length;\n        for (var i = 0; i < modulesCount; i++)\n            darkCount += data.data[i];\n        var k = Math.abs(Math.ceil((darkCount * 100 / modulesCount) / 5) - 10);\n        return k * PenaltyScores.N4;\n    };\n    /**\n     * Return mask value at given position\n     *\n     * @param  {Number} maskPattern Pattern reference value\n     * @param  {Number} i           Row\n     * @param  {Number} j           Column\n     * @return {Boolean}            Mask value\n     */\n    function getMaskAt(maskPattern, i, j) {\n        switch (maskPattern) {\n            case exports.Patterns.PATTERN000: return (i + j) % 2 === 0;\n            case exports.Patterns.PATTERN001: return i % 2 === 0;\n            case exports.Patterns.PATTERN010: return j % 3 === 0;\n            case exports.Patterns.PATTERN011: return (i + j) % 3 === 0;\n            case exports.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;\n            case exports.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0;\n            case exports.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0;\n            case exports.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0;\n            default: throw new Error('bad maskPattern:' + maskPattern);\n        }\n    }\n    /**\n     * Apply a mask pattern to a BitMatrix\n     *\n     * @param  {Number}    pattern Pattern reference number\n     * @param  {BitMatrix} data    BitMatrix data\n     */\n    exports.applyMask = function applyMask(pattern, data) {\n        var size = data.size;\n        for (var col = 0; col < size; col++) {\n            for (var row = 0; row < size; row++) {\n                if (data.isReserved(row, col))\n                    continue;\n                data.xor(row, col, getMaskAt(pattern, row, col));\n            }\n        }\n    };\n    /**\n     * Returns the best mask pattern for data\n     *\n     * @param  {BitMatrix} data\n     * @return {Number} Mask pattern reference number\n     */\n    exports.getBestMask = function getBestMask(data, setupFormatFunc) {\n        var numPatterns = Object.keys(exports.Patterns).length;\n        var bestPattern = 0;\n        var lowerPenalty = Infinity;\n        for (var p = 0; p < numPatterns; p++) {\n            setupFormatFunc(p);\n            exports.applyMask(p, data);\n            // Calculate penalty\n            var penalty = exports.getPenaltyN1(data) +\n                exports.getPenaltyN2(data) +\n                exports.getPenaltyN3(data) +\n                exports.getPenaltyN4(data);\n            // Undo previously applied mask\n            exports.applyMask(p, data);\n            if (penalty < lowerPenalty) {\n                lowerPenalty = penalty;\n                bestPattern = p;\n            }\n        }\n        return bestPattern;\n    };\n});\nvar EC_BLOCKS_TABLE = [\n    // L  M  Q  H\n    1, 1, 1, 1,\n    1, 1, 1, 1,\n    1, 1, 2, 2,\n    1, 2, 2, 4,\n    1, 2, 4, 4,\n    2, 4, 4, 4,\n    2, 4, 6, 5,\n    2, 4, 6, 6,\n    2, 5, 8, 8,\n    4, 5, 8, 8,\n    4, 5, 8, 11,\n    4, 8, 10, 11,\n    4, 9, 12, 16,\n    4, 9, 16, 16,\n    6, 10, 12, 18,\n    6, 10, 17, 16,\n    6, 11, 16, 19,\n    6, 13, 18, 21,\n    7, 14, 21, 25,\n    8, 16, 20, 25,\n    8, 17, 23, 25,\n    9, 17, 23, 34,\n    9, 18, 25, 30,\n    10, 20, 27, 32,\n    12, 21, 29, 35,\n    12, 23, 34, 37,\n    12, 25, 34, 40,\n    13, 26, 35, 42,\n    14, 28, 38, 45,\n    15, 29, 40, 48,\n    16, 31, 43, 51,\n    17, 33, 45, 54,\n    18, 35, 48, 57,\n    19, 37, 51, 60,\n    19, 38, 53, 63,\n    20, 40, 56, 66,\n    21, 43, 59, 70,\n    22, 45, 62, 74,\n    24, 47, 65, 77,\n    25, 49, 68, 81\n];\nvar EC_CODEWORDS_TABLE = [\n    // L  M  Q  H\n    7, 10, 13, 17,\n    10, 16, 22, 28,\n    15, 26, 36, 44,\n    20, 36, 52, 64,\n    26, 48, 72, 88,\n    36, 64, 96, 112,\n    40, 72, 108, 130,\n    48, 88, 132, 156,\n    60, 110, 160, 192,\n    72, 130, 192, 224,\n    80, 150, 224, 264,\n    96, 176, 260, 308,\n    104, 198, 288, 352,\n    120, 216, 320, 384,\n    132, 240, 360, 432,\n    144, 280, 408, 480,\n    168, 308, 448, 532,\n    180, 338, 504, 588,\n    196, 364, 546, 650,\n    224, 416, 600, 700,\n    224, 442, 644, 750,\n    252, 476, 690, 816,\n    270, 504, 750, 900,\n    300, 560, 810, 960,\n    312, 588, 870, 1050,\n    336, 644, 952, 1110,\n    360, 700, 1020, 1200,\n    390, 728, 1050, 1260,\n    420, 784, 1140, 1350,\n    450, 812, 1200, 1440,\n    480, 868, 1290, 1530,\n    510, 924, 1350, 1620,\n    540, 980, 1440, 1710,\n    570, 1036, 1530, 1800,\n    570, 1064, 1590, 1890,\n    600, 1120, 1680, 1980,\n    630, 1204, 1770, 2100,\n    660, 1260, 1860, 2220,\n    720, 1316, 1950, 2310,\n    750, 1372, 2040, 2430\n];\n/**\n * Returns the number of error correction block that the QR Code should contain\n * for the specified version and error correction level.\n *\n * @param  {Number} version              QR Code version\n * @param  {Number} errorCorrectionLevel Error correction level\n * @return {Number}                      Number of error correction blocks\n */\nvar getBlocksCount = function getBlocksCount(version, errorCorrectionLevel$1) {\n    switch (errorCorrectionLevel$1) {\n        case errorCorrectionLevel.L:\n            return EC_BLOCKS_TABLE[(version - 1) * 4 + 0];\n        case errorCorrectionLevel.M:\n            return EC_BLOCKS_TABLE[(version - 1) * 4 + 1];\n        case errorCorrectionLevel.Q:\n            return EC_BLOCKS_TABLE[(version - 1) * 4 + 2];\n        case errorCorrectionLevel.H:\n            return EC_BLOCKS_TABLE[(version - 1) * 4 + 3];\n        default:\n            return undefined;\n    }\n};\n/**\n * Returns the number of error correction codewords to use for the specified\n * version and error correction level.\n *\n * @param  {Number} version              QR Code version\n * @param  {Number} errorCorrectionLevel Error correction level\n * @return {Number}                      Number of error correction codewords\n */\nvar getTotalCodewordsCount = function getTotalCodewordsCount(version, errorCorrectionLevel$1) {\n    switch (errorCorrectionLevel$1) {\n        case errorCorrectionLevel.L:\n            return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0];\n        case errorCorrectionLevel.M:\n            return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1];\n        case errorCorrectionLevel.Q:\n            return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2];\n        case errorCorrectionLevel.H:\n            return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3];\n        default:\n            return undefined;\n    }\n};\nvar errorCorrectionCode = {\n    getBlocksCount: getBlocksCount,\n    getTotalCodewordsCount: getTotalCodewordsCount\n};\nvar EXP_TABLE = typedarrayBuffer.alloc(512);\nvar LOG_TABLE = typedarrayBuffer.alloc(256);\n(function initTables() {\n    var x = 1;\n    for (var i = 0; i < 255; i++) {\n        EXP_TABLE[i] = x;\n        LOG_TABLE[x] = i;\n        x <<= 1; // multiply by 2\n        // The QR code specification says to use byte-wise modulo 100011101 arithmetic.\n        // This means that when a number is 256 or larger, it should be XORed with 0x11D.\n        if (x & 0x100) { // similar to x >= 256, but a lot faster (because 0x100 == 256)\n            x ^= 0x11D;\n        }\n    }\n    // Optimization: double the size of the anti-log table so that we don't need to mod 255 to\n    // stay inside the bounds (because we will mainly use this table for the multiplication of\n    // two GF numbers, no more).\n    // @see {@link mul}\n    for (i = 255; i < 512; i++) {\n        EXP_TABLE[i] = EXP_TABLE[i - 255];\n    }\n}());\n/**\n * Returns log value of n inside Galois Field\n *\n * @param  {Number} n\n * @return {Number}\n */\nvar log = function log(n) {\n    if (n < 1)\n        throw new Error('log(' + n + ')');\n    return LOG_TABLE[n];\n};\n/**\n * Returns anti-log value of n inside Galois Field\n *\n * @param  {Number} n\n * @return {Number}\n */\nvar exp = function exp(n) {\n    return EXP_TABLE[n];\n};\n/**\n * Multiplies two number inside Galois Field\n *\n * @param  {Number} x\n * @param  {Number} y\n * @return {Number}\n */\nvar mul = function mul(x, y) {\n    if (x === 0 || y === 0)\n        return 0;\n    // should be EXP_TABLE[(LOG_TABLE[x] + LOG_TABLE[y]) % 255] if EXP_TABLE wasn't oversized\n    // @see {@link initTables}\n    return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];\n};\nvar galoisField = {\n    log: log,\n    exp: exp,\n    mul: mul\n};\nvar polynomial = createCommonjsModule(function (module, exports) {\n    /**\n     * Multiplies two polynomials inside Galois Field\n     *\n     * @param  {Buffer} p1 Polynomial\n     * @param  {Buffer} p2 Polynomial\n     * @return {Buffer}    Product of p1 and p2\n     */\n    exports.mul = function mul(p1, p2) {\n        var coeff = typedarrayBuffer.alloc(p1.length + p2.length - 1);\n        for (var i = 0; i < p1.length; i++) {\n            for (var j = 0; j < p2.length; j++) {\n                coeff[i + j] ^= galoisField.mul(p1[i], p2[j]);\n            }\n        }\n        return coeff;\n    };\n    /**\n     * Calculate the remainder of polynomials division\n     *\n     * @param  {Buffer} divident Polynomial\n     * @param  {Buffer} divisor  Polynomial\n     * @return {Buffer}          Remainder\n     */\n    exports.mod = function mod(divident, divisor) {\n        var result = typedarrayBuffer.from(divident);\n        while ((result.length - divisor.length) >= 0) {\n            var coeff = result[0];\n            for (var i = 0; i < divisor.length; i++) {\n                result[i] ^= galoisField.mul(divisor[i], coeff);\n            }\n            // remove all zeros from buffer head\n            var offset = 0;\n            while (offset < result.length && result[offset] === 0)\n                offset++;\n            result = result.slice(offset);\n        }\n        return result;\n    };\n    /**\n     * Generate an irreducible generator polynomial of specified degree\n     * (used by Reed-Solomon encoder)\n     *\n     * @param  {Number} degree Degree of the generator polynomial\n     * @return {Buffer}        Buffer containing polynomial coefficients\n     */\n    exports.generateECPolynomial = function generateECPolynomial(degree) {\n        var poly = typedarrayBuffer.from([1]);\n        for (var i = 0; i < degree; i++) {\n            poly = exports.mul(poly, [1, galoisField.exp(i)]);\n        }\n        return poly;\n    };\n});\nvar Buffer$1 = buffer.Buffer;\nfunction ReedSolomonEncoder(degree) {\n    this.genPoly = undefined;\n    this.degree = degree;\n    if (this.degree)\n        this.initialize(this.degree);\n}\n/**\n * Initialize the encoder.\n * The input param should correspond to the number of error correction codewords.\n *\n * @param  {Number} degree\n */\nReedSolomonEncoder.prototype.initialize = function initialize(degree) {\n    // create an irreducible generator polynomial\n    this.degree = degree;\n    this.genPoly = polynomial.generateECPolynomial(this.degree);\n};\n/**\n * Encodes a chunk of data\n *\n * @param  {Buffer} data Buffer containing input data\n * @return {Buffer}      Buffer containing encoded data\n */\nReedSolomonEncoder.prototype.encode = function encode(data) {\n    if (!this.genPoly) {\n        throw new Error('Encoder not initialized');\n    }\n    // Calculate EC for this data block\n    // extends data size to data+genPoly size\n    var pad = typedarrayBuffer.alloc(this.degree);\n    var paddedData = Buffer$1.concat([data, pad], data.length + this.degree);\n    // The error correction codewords are the remainder after dividing the data codewords\n    // by a generator polynomial\n    var remainder = polynomial.mod(paddedData, this.genPoly);\n    // return EC data blocks (last n byte, where n is the degree of genPoly)\n    // If coefficients number in remainder are less than genPoly degree,\n    // pad with 0s to the left to reach the needed number of coefficients\n    var start = this.degree - remainder.length;\n    if (start > 0) {\n        var buff = typedarrayBuffer.alloc(this.degree);\n        remainder.copy(buff, start);\n        return buff;\n    }\n    return remainder;\n};\nvar reedSolomonEncoder = ReedSolomonEncoder;\n/**\n * Check if QR Code version is valid\n *\n * @param  {Number}  version QR Code version\n * @return {Boolean}         true if valid version, false otherwise\n */\nvar isValid = function isValid(version) {\n    return !isNaN(version) && version >= 1 && version <= 40;\n};\nvar versionCheck = {\n    isValid: isValid\n};\nvar numeric = '[0-9]+';\nvar alphanumeric = '[A-Z $%*+\\\\-./:]+';\nvar kanji = '(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|' +\n    '[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|' +\n    '[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|' +\n    '[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+';\nkanji = kanji.replace(/u/g, '\\\\u');\nvar byte = '(?:(?![A-Z0-9 $%*+\\\\-./:]|' + kanji + ')(?:.|[\\r\\n]))+';\nvar KANJI = new RegExp(kanji, 'g');\nvar BYTE_KANJI = new RegExp('[^A-Z0-9 $%*+\\\\-./:]+', 'g');\nvar BYTE = new RegExp(byte, 'g');\nvar NUMERIC = new RegExp(numeric, 'g');\nvar ALPHANUMERIC = new RegExp(alphanumeric, 'g');\nvar TEST_KANJI = new RegExp('^' + kanji + '$');\nvar TEST_NUMERIC = new RegExp('^' + numeric + '$');\nvar TEST_ALPHANUMERIC = new RegExp('^[A-Z0-9 $%*+\\\\-./:]+$');\nvar testKanji = function testKanji(str) {\n    return TEST_KANJI.test(str);\n};\nvar testNumeric = function testNumeric(str) {\n    return TEST_NUMERIC.test(str);\n};\nvar testAlphanumeric = function testAlphanumeric(str) {\n    return TEST_ALPHANUMERIC.test(str);\n};\nvar regex = {\n    KANJI: KANJI,\n    BYTE_KANJI: BYTE_KANJI,\n    BYTE: BYTE,\n    NUMERIC: NUMERIC,\n    ALPHANUMERIC: ALPHANUMERIC,\n    testKanji: testKanji,\n    testNumeric: testNumeric,\n    testAlphanumeric: testAlphanumeric\n};\nvar mode = createCommonjsModule(function (module, exports) {\n    /**\n     * Numeric mode encodes data from the decimal digit set (0 - 9)\n     * (byte values 30HEX to 39HEX).\n     * Normally, 3 data characters are represented by 10 bits.\n     *\n     * @type {Object}\n     */\n    exports.NUMERIC = {\n        id: 'Numeric',\n        bit: 1 << 0,\n        ccBits: [10, 12, 14]\n    };\n    /**\n     * Alphanumeric mode encodes data from a set of 45 characters,\n     * i.e. 10 numeric digits (0 - 9),\n     *      26 alphabetic characters (A - Z),\n     *   and 9 symbols (SP, $, %, *, +, -, ., /, :).\n     * Normally, two input characters are represented by 11 bits.\n     *\n     * @type {Object}\n     */\n    exports.ALPHANUMERIC = {\n        id: 'Alphanumeric',\n        bit: 1 << 1,\n        ccBits: [9, 11, 13]\n    };\n    /**\n     * In byte mode, data is encoded at 8 bits per character.\n     *\n     * @type {Object}\n     */\n    exports.BYTE = {\n        id: 'Byte',\n        bit: 1 << 2,\n        ccBits: [8, 16, 16]\n    };\n    /**\n     * The Kanji mode efficiently encodes Kanji characters in accordance with\n     * the Shift JIS system based on JIS X 0208.\n     * The Shift JIS values are shifted from the JIS X 0208 values.\n     * JIS X 0208 gives details of the shift coded representation.\n     * Each two-byte character value is compacted to a 13-bit binary codeword.\n     *\n     * @type {Object}\n     */\n    exports.KANJI = {\n        id: 'Kanji',\n        bit: 1 << 3,\n        ccBits: [8, 10, 12]\n    };\n    /**\n     * Mixed mode will contain a sequences of data in a combination of any of\n     * the modes described above\n     *\n     * @type {Object}\n     */\n    exports.MIXED = {\n        bit: -1\n    };\n    /**\n     * Returns the number of bits needed to store the data length\n     * according to QR Code specifications.\n     *\n     * @param  {Mode}   mode    Data mode\n     * @param  {Number} version QR Code version\n     * @return {Number}         Number of bits\n     */\n    exports.getCharCountIndicator = function getCharCountIndicator(mode, version) {\n        if (!mode.ccBits)\n            throw new Error('Invalid mode: ' + mode);\n        if (!versionCheck.isValid(version)) {\n            throw new Error('Invalid version: ' + version);\n        }\n        if (version >= 1 && version < 10)\n            return mode.ccBits[0];\n        else if (version < 27)\n            return mode.ccBits[1];\n        return mode.ccBits[2];\n    };\n    /**\n     * Returns the most efficient mode to store the specified data\n     *\n     * @param  {String} dataStr Input data string\n     * @return {Mode}           Best mode\n     */\n    exports.getBestModeForData = function getBestModeForData(dataStr) {\n        if (regex.testNumeric(dataStr))\n            return exports.NUMERIC;\n        else if (regex.testAlphanumeric(dataStr))\n            return exports.ALPHANUMERIC;\n        else if (regex.testKanji(dataStr))\n            return exports.KANJI;\n        else\n            return exports.BYTE;\n    };\n    /**\n     * Return mode name as string\n     *\n     * @param {Mode} mode Mode object\n     * @returns {String}  Mode name\n     */\n    exports.toString = function toString(mode) {\n        if (mode && mode.id)\n            return mode.id;\n        throw new Error('Invalid mode');\n    };\n    /**\n     * Check if input param is a valid mode object\n     *\n     * @param   {Mode}    mode Mode object\n     * @returns {Boolean} True if valid mode, false otherwise\n     */\n    exports.isValid = function isValid(mode) {\n        return mode && mode.bit && mode.ccBits;\n    };\n    /**\n     * Get mode object from its name\n     *\n     * @param   {String} string Mode name\n     * @returns {Mode}          Mode object\n     */\n    function fromString(string) {\n        if (typeof string !== 'string') {\n            throw new Error('Param is not a string');\n        }\n        var lcStr = string.toLowerCase();\n        switch (lcStr) {\n            case 'numeric':\n                return exports.NUMERIC;\n            case 'alphanumeric':\n                return exports.ALPHANUMERIC;\n            case 'kanji':\n                return exports.KANJI;\n            case 'byte':\n                return exports.BYTE;\n            default:\n                throw new Error('Unknown mode: ' + string);\n        }\n    }\n    /**\n     * Returns mode from a value.\n     * If value is not a valid mode, returns defaultValue\n     *\n     * @param  {Mode|String} value        Encoding mode\n     * @param  {Mode}        defaultValue Fallback value\n     * @return {Mode}                     Encoding mode\n     */\n    exports.from = function from(value, defaultValue) {\n        if (exports.isValid(value)) {\n            return value;\n        }\n        try {\n            return fromString(value);\n        }\n        catch (e) {\n            return defaultValue;\n        }\n    };\n});\nvar version = createCommonjsModule(function (module, exports) {\n    // Generator polynomial used to encode version information\n    var G18 = (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0);\n    var G18_BCH = utils.getBCHDigit(G18);\n    function getBestVersionForDataLength(mode, length, errorCorrectionLevel) {\n        for (var currentVersion = 1; currentVersion <= 40; currentVersion++) {\n            if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode)) {\n                return currentVersion;\n            }\n        }\n        return undefined;\n    }\n    function getReservedBitsCount(mode$1, version) {\n        // Character count indicator + mode indicator bits\n        return mode.getCharCountIndicator(mode$1, version) + 4;\n    }\n    function getTotalBitsFromDataArray(segments, version) {\n        var totalBits = 0;\n        segments.forEach(function (data) {\n            var reservedBits = getReservedBitsCount(data.mode, version);\n            totalBits += reservedBits + data.getBitsLength();\n        });\n        return totalBits;\n    }\n    function getBestVersionForMixedData(segments, errorCorrectionLevel) {\n        for (var currentVersion = 1; currentVersion <= 40; currentVersion++) {\n            var length = getTotalBitsFromDataArray(segments, currentVersion);\n            if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode.MIXED)) {\n                return currentVersion;\n            }\n        }\n        return undefined;\n    }\n    /**\n     * Returns version number from a value.\n     * If value is not a valid version, returns defaultValue\n     *\n     * @param  {Number|String} value        QR Code version\n     * @param  {Number}        defaultValue Fallback value\n     * @return {Number}                     QR Code version number\n     */\n    exports.from = function from(value, defaultValue) {\n        if (versionCheck.isValid(value)) {\n            return parseInt(value, 10);\n        }\n        return defaultValue;\n    };\n    /**\n     * Returns how much data can be stored with the specified QR code version\n     * and error correction level\n     *\n     * @param  {Number} version              QR Code version (1-40)\n     * @param  {Number} errorCorrectionLevel Error correction level\n     * @param  {Mode}   mode                 Data mode\n     * @return {Number}                      Quantity of storable data\n     */\n    exports.getCapacity = function getCapacity(version, errorCorrectionLevel, mode$1) {\n        if (!versionCheck.isValid(version)) {\n            throw new Error('Invalid QR Code version');\n        }\n        // Use Byte mode as default\n        if (typeof mode$1 === 'undefined')\n            mode$1 = mode.BYTE;\n        // Total codewords for this QR code version (Data + Error correction)\n        var totalCodewords = utils.getSymbolTotalCodewords(version);\n        // Total number of error correction codewords\n        var ecTotalCodewords = errorCorrectionCode.getTotalCodewordsCount(version, errorCorrectionLevel);\n        // Total number of data codewords\n        var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;\n        if (mode$1 === mode.MIXED)\n            return dataTotalCodewordsBits;\n        var usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode$1, version);\n        // Return max number of storable codewords\n        switch (mode$1) {\n            case mode.NUMERIC:\n                return Math.floor((usableBits / 10) * 3);\n            case mode.ALPHANUMERIC:\n                return Math.floor((usableBits / 11) * 2);\n            case mode.KANJI:\n                return Math.floor(usableBits / 13);\n            case mode.BYTE:\n            default:\n                return Math.floor(usableBits / 8);\n        }\n    };\n    /**\n     * Returns the minimum version needed to contain the amount of data\n     *\n     * @param  {Segment} data                    Segment of data\n     * @param  {Number} [errorCorrectionLevel=H] Error correction level\n     * @param  {Mode} mode                       Data mode\n     * @return {Number}                          QR Code version\n     */\n    exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel$1) {\n        var seg;\n        var ecl = errorCorrectionLevel.from(errorCorrectionLevel$1, errorCorrectionLevel.M);\n        if (isarray(data)) {\n            if (data.length > 1) {\n                return getBestVersionForMixedData(data, ecl);\n            }\n            if (data.length === 0) {\n                return 1;\n            }\n            seg = data[0];\n        }\n        else {\n            seg = data;\n        }\n        return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);\n    };\n    /**\n     * Returns version information with relative error correction bits\n     *\n     * The version information is included in QR Code symbols of version 7 or larger.\n     * It consists of an 18-bit sequence containing 6 data bits,\n     * with 12 error correction bits calculated using the (18, 6) Golay code.\n     *\n     * @param  {Number} version QR Code version\n     * @return {Number}         Encoded version info bits\n     */\n    exports.getEncodedBits = function getEncodedBits(version) {\n        if (!versionCheck.isValid(version) || version < 7) {\n            throw new Error('Invalid QR Code version');\n        }\n        var d = version << 12;\n        while (utils.getBCHDigit(d) - G18_BCH >= 0) {\n            d ^= (G18 << (utils.getBCHDigit(d) - G18_BCH));\n        }\n        return (version << 12) | d;\n    };\n});\nvar G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0);\nvar G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1);\nvar G15_BCH = utils.getBCHDigit(G15);\n/**\n * Returns format information with relative error correction bits\n *\n * The format information is a 15-bit sequence containing 5 data bits,\n * with 10 error correction bits calculated using the (15, 5) BCH code.\n *\n * @param  {Number} errorCorrectionLevel Error correction level\n * @param  {Number} mask                 Mask pattern\n * @return {Number}                      Encoded format information bits\n */\nvar getEncodedBits = function getEncodedBits(errorCorrectionLevel, mask) {\n    var data = ((errorCorrectionLevel.bit << 3) | mask);\n    var d = data << 10;\n    while (utils.getBCHDigit(d) - G15_BCH >= 0) {\n        d ^= (G15 << (utils.getBCHDigit(d) - G15_BCH));\n    }\n    // xor final data with mask pattern in order to ensure that\n    // no combination of Error Correction Level and data mask pattern\n    // will result in an all-zero data string\n    return ((data << 10) | d) ^ G15_MASK;\n};\nvar formatInfo = {\n    getEncodedBits: getEncodedBits\n};\nfunction NumericData(data) {\n    this.mode = mode.NUMERIC;\n    this.data = data.toString();\n}\nNumericData.getBitsLength = function getBitsLength(length) {\n    return 10 * Math.floor(length / 3) + ((length % 3) ? ((length % 3) * 3 + 1) : 0);\n};\nNumericData.prototype.getLength = function getLength() {\n    return this.data.length;\n};\nNumericData.prototype.getBitsLength = function getBitsLength() {\n    return NumericData.getBitsLength(this.data.length);\n};\nNumericData.prototype.write = function write(bitBuffer) {\n    var i, group, value;\n    // The input data string is divided into groups of three digits,\n    // and each group is converted to its 10-bit binary equivalent.\n    for (i = 0; i + 3 <= this.data.length; i += 3) {\n        group = this.data.substr(i, 3);\n        value = parseInt(group, 10);\n        bitBuffer.put(value, 10);\n    }\n    // If the number of input digits is not an exact multiple of three,\n    // the final one or two digits are converted to 4 or 7 bits respectively.\n    var remainingNum = this.data.length - i;\n    if (remainingNum > 0) {\n        group = this.data.substr(i);\n        value = parseInt(group, 10);\n        bitBuffer.put(value, remainingNum * 3 + 1);\n    }\n};\nvar numericData = NumericData;\n/**\n * Array of characters available in alphanumeric mode\n *\n * As per QR Code specification, to each character\n * is assigned a value from 0 to 44 which in this case coincides\n * with the array index\n *\n * @type {Array}\n */\nvar ALPHA_NUM_CHARS = [\n    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',\n    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',\n    ' ', '$', '%', '*', '+', '-', '.', '/', ':'\n];\nfunction AlphanumericData(data) {\n    this.mode = mode.ALPHANUMERIC;\n    this.data = data;\n}\nAlphanumericData.getBitsLength = function getBitsLength(length) {\n    return 11 * Math.floor(length / 2) + 6 * (length % 2);\n};\nAlphanumericData.prototype.getLength = function getLength() {\n    return this.data.length;\n};\nAlphanumericData.prototype.getBitsLength = function getBitsLength() {\n    return AlphanumericData.getBitsLength(this.data.length);\n};\nAlphanumericData.prototype.write = function write(bitBuffer) {\n    var i;\n    // Input data characters are divided into groups of two characters\n    // and encoded as 11-bit binary codes.\n    for (i = 0; i + 2 <= this.data.length; i += 2) {\n        // The character value of the first character is multiplied by 45\n        var value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;\n        // The character value of the second digit is added to the product\n        value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);\n        // The sum is then stored as 11-bit binary number\n        bitBuffer.put(value, 11);\n    }\n    // If the number of input data characters is not a multiple of two,\n    // the character value of the final character is encoded as a 6-bit binary number.\n    if (this.data.length % 2) {\n        bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);\n    }\n};\nvar alphanumericData = AlphanumericData;\nfunction ByteData(data) {\n    this.mode = mode.BYTE;\n    this.data = typedarrayBuffer.from(data);\n}\nByteData.getBitsLength = function getBitsLength(length) {\n    return length * 8;\n};\nByteData.prototype.getLength = function getLength() {\n    return this.data.length;\n};\nByteData.prototype.getBitsLength = function getBitsLength() {\n    return ByteData.getBitsLength(this.data.length);\n};\nByteData.prototype.write = function (bitBuffer) {\n    for (var i = 0, l = this.data.length; i < l; i++) {\n        bitBuffer.put(this.data[i], 8);\n    }\n};\nvar byteData = ByteData;\nfunction KanjiData(data) {\n    this.mode = mode.KANJI;\n    this.data = data;\n}\nKanjiData.getBitsLength = function getBitsLength(length) {\n    return length * 13;\n};\nKanjiData.prototype.getLength = function getLength() {\n    return this.data.length;\n};\nKanjiData.prototype.getBitsLength = function getBitsLength() {\n    return KanjiData.getBitsLength(this.data.length);\n};\nKanjiData.prototype.write = function (bitBuffer) {\n    var i;\n    // In the Shift JIS system, Kanji characters are represented by a two byte combination.\n    // These byte values are shifted from the JIS X 0208 values.\n    // JIS X 0208 gives details of the shift coded representation.\n    for (i = 0; i < this.data.length; i++) {\n        var value = utils.toSJIS(this.data[i]);\n        // For characters with Shift JIS values from 0x8140 to 0x9FFC:\n        if (value >= 0x8140 && value <= 0x9FFC) {\n            // Subtract 0x8140 from Shift JIS value\n            value -= 0x8140;\n            // For characters with Shift JIS values from 0xE040 to 0xEBBF\n        }\n        else if (value >= 0xE040 && value <= 0xEBBF) {\n            // Subtract 0xC140 from Shift JIS value\n            value -= 0xC140;\n        }\n        else {\n            throw new Error('Invalid SJIS character: ' + this.data[i] + '\\n' +\n                'Make sure your charset is UTF-8');\n        }\n        // Multiply most significant byte of result by 0xC0\n        // and add least significant byte to product\n        value = (((value >>> 8) & 0xff) * 0xC0) + (value & 0xff);\n        // Convert result to a 13-bit binary string\n        bitBuffer.put(value, 13);\n    }\n};\nvar kanjiData = KanjiData;\nvar dijkstra_1 = createCommonjsModule(function (module) {\n    /******************************************************************************\n     * Created 2008-08-19.\n     *\n     * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n     *\n     * Copyright (C) 2008\n     *   Wyatt Baldwin <self@wyattbaldwin.com>\n     *   All rights reserved\n     *\n     * Licensed under the MIT license.\n     *\n     *   http://www.opensource.org/licenses/mit-license.php\n     *\n     * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n     * THE SOFTWARE.\n     *****************************************************************************/\n    var dijkstra = {\n        single_source_shortest_paths: function (graph, s, d) {\n            // Predecessor map for each node that has been encountered.\n            // node ID => predecessor node ID\n            var predecessors = {};\n            // Costs of shortest paths from s to all nodes encountered.\n            // node ID => cost\n            var costs = {};\n            costs[s] = 0;\n            // Costs of shortest paths from s to all nodes encountered; differs from\n            // `costs` in that it provides easy access to the node that currently has\n            // the known shortest path from s.\n            // XXX: Do we actually need both `costs` and `open`?\n            var open = dijkstra.PriorityQueue.make();\n            open.push(s, 0);\n            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;\n            while (!open.empty()) {\n                // In the nodes remaining in graph that have a known cost from s,\n                // find the node, u, that currently has the shortest path from s.\n                closest = open.pop();\n                u = closest.value;\n                cost_of_s_to_u = closest.cost;\n                // Get nodes adjacent to u...\n                adjacent_nodes = graph[u] || {};\n                // ...and explore the edges that connect u to those nodes, updating\n                // the cost of the shortest paths to any or all of those nodes as\n                // necessary. v is the node across the current edge from u.\n                for (v in adjacent_nodes) {\n                    if (adjacent_nodes.hasOwnProperty(v)) {\n                        // Get the cost of the edge running from u to v.\n                        cost_of_e = adjacent_nodes[v];\n                        // Cost of s to u plus the cost of u to v across e--this is *a*\n                        // cost from s to v that may or may not be less than the current\n                        // known cost to v.\n                        cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n                        // If we haven't visited v yet OR if the current known cost from s to\n                        // v is greater than the new cost we just found (cost of s to u plus\n                        // cost of u to v across e), update v's cost in the cost list and\n                        // update v's predecessor in the predecessor list (it's now u).\n                        cost_of_s_to_v = costs[v];\n                        first_visit = (typeof costs[v] === 'undefined');\n                        if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n                            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n                            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n                            predecessors[v] = u;\n                        }\n                    }\n                }\n            }\n            if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n                var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n                throw new Error(msg);\n            }\n            return predecessors;\n        },\n        extract_shortest_path_from_predecessor_list: function (predecessors, d) {\n            var nodes = [];\n            var u = d;\n            while (u) {\n                nodes.push(u);\n                u = predecessors[u];\n            }\n            nodes.reverse();\n            return nodes;\n        },\n        find_path: function (graph, s, d) {\n            var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n            return dijkstra.extract_shortest_path_from_predecessor_list(predecessors, d);\n        },\n        /**\n         * A very naive priority queue implementation.\n         */\n        PriorityQueue: {\n            make: function (opts) {\n                var T = dijkstra.PriorityQueue, t = {}, key;\n                opts = opts || {};\n                for (key in T) {\n                    if (T.hasOwnProperty(key)) {\n                        t[key] = T[key];\n                    }\n                }\n                t.queue = [];\n                t.sorter = opts.sorter || T.default_sorter;\n                return t;\n            },\n            default_sorter: function (a, b) {\n                return a.cost - b.cost;\n            },\n            /**\n             * Add a new item to the queue and ensure the highest priority element\n             * is at the front of the queue.\n             */\n            push: function (value, cost) {\n                var item = { value: value, cost: cost };\n                this.queue.push(item);\n                this.queue.sort(this.sorter);\n            },\n            /**\n             * Return the highest priority element in the queue.\n             */\n            pop: function () {\n                return this.queue.shift();\n            },\n            empty: function () {\n                return this.queue.length === 0;\n            }\n        }\n    };\n    // node.js module exports\n    {\n        module.exports = dijkstra;\n    }\n});\nvar segments = createCommonjsModule(function (module, exports) {\n    /**\n     * Returns UTF8 byte length\n     *\n     * @param  {String} str Input string\n     * @return {Number}     Number of byte\n     */\n    function getStringByteLength(str) {\n        return unescape(encodeURIComponent(str)).length;\n    }\n    /**\n     * Get a list of segments of the specified mode\n     * from a string\n     *\n     * @param  {Mode}   mode Segment mode\n     * @param  {String} str  String to process\n     * @return {Array}       Array of object with segments data\n     */\n    function getSegments(regex, mode, str) {\n        var segments = [];\n        var result;\n        while ((result = regex.exec(str)) !== null) {\n            segments.push({\n                data: result[0],\n                index: result.index,\n                mode: mode,\n                length: result[0].length\n            });\n        }\n        return segments;\n    }\n    /**\n     * Extracts a series of segments with the appropriate\n     * modes from a string\n     *\n     * @param  {String} dataStr Input string\n     * @return {Array}          Array of object with segments data\n     */\n    function getSegmentsFromString(dataStr) {\n        var numSegs = getSegments(regex.NUMERIC, mode.NUMERIC, dataStr);\n        var alphaNumSegs = getSegments(regex.ALPHANUMERIC, mode.ALPHANUMERIC, dataStr);\n        var byteSegs;\n        var kanjiSegs;\n        if (utils.isKanjiModeEnabled()) {\n            byteSegs = getSegments(regex.BYTE, mode.BYTE, dataStr);\n            kanjiSegs = getSegments(regex.KANJI, mode.KANJI, dataStr);\n        }\n        else {\n            byteSegs = getSegments(regex.BYTE_KANJI, mode.BYTE, dataStr);\n            kanjiSegs = [];\n        }\n        var segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);\n        return segs\n            .sort(function (s1, s2) {\n            return s1.index - s2.index;\n        })\n            .map(function (obj) {\n            return {\n                data: obj.data,\n                mode: obj.mode,\n                length: obj.length\n            };\n        });\n    }\n    /**\n     * Returns how many bits are needed to encode a string of\n     * specified length with the specified mode\n     *\n     * @param  {Number} length String length\n     * @param  {Mode} mode     Segment mode\n     * @return {Number}        Bit length\n     */\n    function getSegmentBitsLength(length, mode$1) {\n        switch (mode$1) {\n            case mode.NUMERIC:\n                return numericData.getBitsLength(length);\n            case mode.ALPHANUMERIC:\n                return alphanumericData.getBitsLength(length);\n            case mode.KANJI:\n                return kanjiData.getBitsLength(length);\n            case mode.BYTE:\n                return byteData.getBitsLength(length);\n        }\n    }\n    /**\n     * Merges adjacent segments which have the same mode\n     *\n     * @param  {Array} segs Array of object with segments data\n     * @return {Array}      Array of object with segments data\n     */\n    function mergeSegments(segs) {\n        return segs.reduce(function (acc, curr) {\n            var prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;\n            if (prevSeg && prevSeg.mode === curr.mode) {\n                acc[acc.length - 1].data += curr.data;\n                return acc;\n            }\n            acc.push(curr);\n            return acc;\n        }, []);\n    }\n    /**\n     * Generates a list of all possible nodes combination which\n     * will be used to build a segments graph.\n     *\n     * Nodes are divided by groups. Each group will contain a list of all the modes\n     * in which is possible to encode the given text.\n     *\n     * For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.\n     * The group for '12345' will contain then 3 objects, one for each\n     * possible encoding mode.\n     *\n     * Each node represents a possible segment.\n     *\n     * @param  {Array} segs Array of object with segments data\n     * @return {Array}      Array of object with segments data\n     */\n    function buildNodes(segs) {\n        var nodes = [];\n        for (var i = 0; i < segs.length; i++) {\n            var seg = segs[i];\n            switch (seg.mode) {\n                case mode.NUMERIC:\n                    nodes.push([seg,\n                        { data: seg.data, mode: mode.ALPHANUMERIC, length: seg.length },\n                        { data: seg.data, mode: mode.BYTE, length: seg.length }\n                    ]);\n                    break;\n                case mode.ALPHANUMERIC:\n                    nodes.push([seg,\n                        { data: seg.data, mode: mode.BYTE, length: seg.length }\n                    ]);\n                    break;\n                case mode.KANJI:\n                    nodes.push([seg,\n                        { data: seg.data, mode: mode.BYTE, length: getStringByteLength(seg.data) }\n                    ]);\n                    break;\n                case mode.BYTE:\n                    nodes.push([\n                        { data: seg.data, mode: mode.BYTE, length: getStringByteLength(seg.data) }\n                    ]);\n            }\n        }\n        return nodes;\n    }\n    /**\n     * Builds a graph from a list of nodes.\n     * All segments in each node group will be connected with all the segments of\n     * the next group and so on.\n     *\n     * At each connection will be assigned a weight depending on the\n     * segment's byte length.\n     *\n     * @param  {Array} nodes    Array of object with segments data\n     * @param  {Number} version QR Code version\n     * @return {Object}         Graph of all possible segments\n     */\n    function buildGraph(nodes, version) {\n        var table = {};\n        var graph = { 'start': {} };\n        var prevNodeIds = ['start'];\n        for (var i = 0; i < nodes.length; i++) {\n            var nodeGroup = nodes[i];\n            var currentNodeIds = [];\n            for (var j = 0; j < nodeGroup.length; j++) {\n                var node = nodeGroup[j];\n                var key = '' + i + j;\n                currentNodeIds.push(key);\n                table[key] = { node: node, lastCount: 0 };\n                graph[key] = {};\n                for (var n = 0; n < prevNodeIds.length; n++) {\n                    var prevNodeId = prevNodeIds[n];\n                    if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {\n                        graph[prevNodeId][key] =\n                            getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -\n                                getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);\n                        table[prevNodeId].lastCount += node.length;\n                    }\n                    else {\n                        if (table[prevNodeId])\n                            table[prevNodeId].lastCount = node.length;\n                        graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +\n                            4 + mode.getCharCountIndicator(node.mode, version); // switch cost\n                    }\n                }\n            }\n            prevNodeIds = currentNodeIds;\n        }\n        for (n = 0; n < prevNodeIds.length; n++) {\n            graph[prevNodeIds[n]]['end'] = 0;\n        }\n        return { map: graph, table: table };\n    }\n    /**\n     * Builds a segment from a specified data and mode.\n     * If a mode is not specified, the more suitable will be used.\n     *\n     * @param  {String} data             Input data\n     * @param  {Mode | String} modesHint Data mode\n     * @return {Segment}                 Segment\n     */\n    function buildSingleSegment(data, modesHint) {\n        var mode$1;\n        var bestMode = mode.getBestModeForData(data);\n        mode$1 = mode.from(modesHint, bestMode);\n        // Make sure data can be encoded\n        if (mode$1 !== mode.BYTE && mode$1.bit < bestMode.bit) {\n            throw new Error('\"' + data + '\"' +\n                ' cannot be encoded with mode ' + mode.toString(mode$1) +\n                '.\\n Suggested mode is: ' + mode.toString(bestMode));\n        }\n        // Use Mode.BYTE if Kanji support is disabled\n        if (mode$1 === mode.KANJI && !utils.isKanjiModeEnabled()) {\n            mode$1 = mode.BYTE;\n        }\n        switch (mode$1) {\n            case mode.NUMERIC:\n                return new numericData(data);\n            case mode.ALPHANUMERIC:\n                return new alphanumericData(data);\n            case mode.KANJI:\n                return new kanjiData(data);\n            case mode.BYTE:\n                return new byteData(data);\n        }\n    }\n    /**\n     * Builds a list of segments from an array.\n     * Array can contain Strings or Objects with segment's info.\n     *\n     * For each item which is a string, will be generated a segment with the given\n     * string and the more appropriate encoding mode.\n     *\n     * For each item which is an object, will be generated a segment with the given\n     * data and mode.\n     * Objects must contain at least the property \"data\".\n     * If property \"mode\" is not present, the more suitable mode will be used.\n     *\n     * @param  {Array} array Array of objects with segments data\n     * @return {Array}       Array of Segments\n     */\n    exports.fromArray = function fromArray(array) {\n        return array.reduce(function (acc, seg) {\n            if (typeof seg === 'string') {\n                acc.push(buildSingleSegment(seg, null));\n            }\n            else if (seg.data) {\n                acc.push(buildSingleSegment(seg.data, seg.mode));\n            }\n            return acc;\n        }, []);\n    };\n    /**\n     * Builds an optimized sequence of segments from a string,\n     * which will produce the shortest possible bitstream.\n     *\n     * @param  {String} data    Input string\n     * @param  {Number} version QR Code version\n     * @return {Array}          Array of segments\n     */\n    exports.fromString = function fromString(data, version) {\n        var segs = getSegmentsFromString(data, utils.isKanjiModeEnabled());\n        var nodes = buildNodes(segs);\n        var graph = buildGraph(nodes, version);\n        var path = dijkstra_1.find_path(graph.map, 'start', 'end');\n        var optimizedSegs = [];\n        for (var i = 1; i < path.length - 1; i++) {\n            optimizedSegs.push(graph.table[path[i]].node);\n        }\n        return exports.fromArray(mergeSegments(optimizedSegs));\n    };\n    /**\n     * Splits a string in various segments with the modes which\n     * best represent their content.\n     * The produced segments are far from being optimized.\n     * The output of this function is only used to estimate a QR Code version\n     * which may contain the data.\n     *\n     * @param  {string} data Input string\n     * @return {Array}       Array of segments\n     */\n    exports.rawSplit = function rawSplit(data) {\n        return exports.fromArray(getSegmentsFromString(data, utils.isKanjiModeEnabled()));\n    };\n});\n/**\n * QRCode for JavaScript\n *\n * modified by Ryan Day for nodejs support\n * Copyright (c) 2011 Ryan Day\n *\n * Licensed under the MIT license:\n *   http://www.opensource.org/licenses/mit-license.php\n *\n//---------------------------------------------------------------------\n// QRCode for JavaScript\n//\n// Copyright (c) 2009 Kazuhiko Arase\n//\n// URL: http://www.d-project.com/\n//\n// Licensed under the MIT license:\n//   http://www.opensource.org/licenses/mit-license.php\n//\n// The word \"QR Code\" is registered trademark of\n// DENSO WAVE INCORPORATED\n//   http://www.denso-wave.com/qrcode/faqpatent-e.html\n//\n//---------------------------------------------------------------------\n*/\n/**\n * Add finder patterns bits to matrix\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupFinderPattern(matrix, version) {\n    var size = matrix.size;\n    var pos = finderPattern.getPositions(version);\n    for (var i = 0; i < pos.length; i++) {\n        var row = pos[i][0];\n        var col = pos[i][1];\n        for (var r = -1; r <= 7; r++) {\n            if (row + r <= -1 || size <= row + r)\n                continue;\n            for (var c = -1; c <= 7; c++) {\n                if (col + c <= -1 || size <= col + c)\n                    continue;\n                if ((r >= 0 && r <= 6 && (c === 0 || c === 6)) ||\n                    (c >= 0 && c <= 6 && (r === 0 || r === 6)) ||\n                    (r >= 2 && r <= 4 && c >= 2 && c <= 4)) {\n                    matrix.set(row + r, col + c, true, true);\n                }\n                else {\n                    matrix.set(row + r, col + c, false, true);\n                }\n            }\n        }\n    }\n}\n/**\n * Add timing pattern bits to matrix\n *\n * Note: this function must be called before {@link setupAlignmentPattern}\n *\n * @param  {BitMatrix} matrix Modules matrix\n */\nfunction setupTimingPattern(matrix) {\n    var size = matrix.size;\n    for (var r = 8; r < size - 8; r++) {\n        var value = r % 2 === 0;\n        matrix.set(r, 6, value, true);\n        matrix.set(6, r, value, true);\n    }\n}\n/**\n * Add alignment patterns bits to matrix\n *\n * Note: this function must be called after {@link setupTimingPattern}\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupAlignmentPattern(matrix, version) {\n    var pos = alignmentPattern.getPositions(version);\n    for (var i = 0; i < pos.length; i++) {\n        var row = pos[i][0];\n        var col = pos[i][1];\n        for (var r = -2; r <= 2; r++) {\n            for (var c = -2; c <= 2; c++) {\n                if (r === -2 || r === 2 || c === -2 || c === 2 ||\n                    (r === 0 && c === 0)) {\n                    matrix.set(row + r, col + c, true, true);\n                }\n                else {\n                    matrix.set(row + r, col + c, false, true);\n                }\n            }\n        }\n    }\n}\n/**\n * Add version info bits to matrix\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupVersionInfo(matrix, version$1) {\n    var size = matrix.size;\n    var bits = version.getEncodedBits(version$1);\n    var row, col, mod;\n    for (var i = 0; i < 18; i++) {\n        row = Math.floor(i / 3);\n        col = i % 3 + size - 8 - 3;\n        mod = ((bits >> i) & 1) === 1;\n        matrix.set(row, col, mod, true);\n        matrix.set(col, row, mod, true);\n    }\n}\n/**\n * Add format info bits to matrix\n *\n * @param  {BitMatrix} matrix               Modules matrix\n * @param  {ErrorCorrectionLevel}    errorCorrectionLevel Error correction level\n * @param  {Number}    maskPattern          Mask pattern reference value\n */\nfunction setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {\n    var size = matrix.size;\n    var bits = formatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);\n    var i, mod;\n    for (i = 0; i < 15; i++) {\n        mod = ((bits >> i) & 1) === 1;\n        // vertical\n        if (i < 6) {\n            matrix.set(i, 8, mod, true);\n        }\n        else if (i < 8) {\n            matrix.set(i + 1, 8, mod, true);\n        }\n        else {\n            matrix.set(size - 15 + i, 8, mod, true);\n        }\n        // horizontal\n        if (i < 8) {\n            matrix.set(8, size - i - 1, mod, true);\n        }\n        else if (i < 9) {\n            matrix.set(8, 15 - i - 1 + 1, mod, true);\n        }\n        else {\n            matrix.set(8, 15 - i - 1, mod, true);\n        }\n    }\n    // fixed module\n    matrix.set(size - 8, 8, 1, true);\n}\n/**\n * Add encoded data bits to matrix\n *\n * @param  {BitMatrix} matrix Modules matrix\n * @param  {Buffer}    data   Data codewords\n */\nfunction setupData(matrix, data) {\n    var size = matrix.size;\n    var inc = -1;\n    var row = size - 1;\n    var bitIndex = 7;\n    var byteIndex = 0;\n    for (var col = size - 1; col > 0; col -= 2) {\n        if (col === 6)\n            col--;\n        while (true) {\n            for (var c = 0; c < 2; c++) {\n                if (!matrix.isReserved(row, col - c)) {\n                    var dark = false;\n                    if (byteIndex < data.length) {\n                        dark = (((data[byteIndex] >>> bitIndex) & 1) === 1);\n                    }\n                    matrix.set(row, col - c, dark);\n                    bitIndex--;\n                    if (bitIndex === -1) {\n                        byteIndex++;\n                        bitIndex = 7;\n                    }\n                }\n            }\n            row += inc;\n            if (row < 0 || size <= row) {\n                row -= inc;\n                inc = -inc;\n                break;\n            }\n        }\n    }\n}\n/**\n * Create encoded codewords from data input\n *\n * @param  {Number}   version              QR Code version\n * @param  {ErrorCorrectionLevel}   errorCorrectionLevel Error correction level\n * @param  {ByteData} data                 Data input\n * @return {Buffer}                        Buffer containing encoded codewords\n */\nfunction createData(version, errorCorrectionLevel, segments) {\n    // Prepare data buffer\n    var buffer = new bitBuffer();\n    segments.forEach(function (data) {\n        // prefix data with mode indicator (4 bits)\n        buffer.put(data.mode.bit, 4);\n        // Prefix data with character count indicator.\n        // The character count indicator is a string of bits that represents the\n        // number of characters that are being encoded.\n        // The character count indicator must be placed after the mode indicator\n        // and must be a certain number of bits long, depending on the QR version\n        // and data mode\n        // @see {@link Mode.getCharCountIndicator}.\n        buffer.put(data.getLength(), mode.getCharCountIndicator(data.mode, version));\n        // add binary data sequence to buffer\n        data.write(buffer);\n    });\n    // Calculate required number of bits\n    var totalCodewords = utils.getSymbolTotalCodewords(version);\n    var ecTotalCodewords = errorCorrectionCode.getTotalCodewordsCount(version, errorCorrectionLevel);\n    var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;\n    // Add a terminator.\n    // If the bit string is shorter than the total number of required bits,\n    // a terminator of up to four 0s must be added to the right side of the string.\n    // If the bit string is more than four bits shorter than the required number of bits,\n    // add four 0s to the end.\n    if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {\n        buffer.put(0, 4);\n    }\n    // If the bit string is fewer than four bits shorter, add only the number of 0s that\n    // are needed to reach the required number of bits.\n    // After adding the terminator, if the number of bits in the string is not a multiple of 8,\n    // pad the string on the right with 0s to make the string's length a multiple of 8.\n    while (buffer.getLengthInBits() % 8 !== 0) {\n        buffer.putBit(0);\n    }\n    // Add pad bytes if the string is still shorter than the total number of required bits.\n    // Extend the buffer to fill the data capacity of the symbol corresponding to\n    // the Version and Error Correction Level by adding the Pad Codewords 11101100 (0xEC)\n    // and 00010001 (0x11) alternately.\n    var remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;\n    for (var i = 0; i < remainingByte; i++) {\n        buffer.put(i % 2 ? 0x11 : 0xEC, 8);\n    }\n    return createCodewords(buffer, version, errorCorrectionLevel);\n}\n/**\n * Encode input data with Reed-Solomon and return codewords with\n * relative error correction bits\n *\n * @param  {BitBuffer} bitBuffer            Data to encode\n * @param  {Number}    version              QR Code version\n * @param  {ErrorCorrectionLevel} errorCorrectionLevel Error correction level\n * @return {Buffer}                         Buffer containing encoded codewords\n */\nfunction createCodewords(bitBuffer, version, errorCorrectionLevel) {\n    // Total codewords for this QR code version (Data + Error correction)\n    var totalCodewords = utils.getSymbolTotalCodewords(version);\n    // Total number of error correction codewords\n    var ecTotalCodewords = errorCorrectionCode.getTotalCodewordsCount(version, errorCorrectionLevel);\n    // Total number of data codewords\n    var dataTotalCodewords = totalCodewords - ecTotalCodewords;\n    // Total number of blocks\n    var ecTotalBlocks = errorCorrectionCode.getBlocksCount(version, errorCorrectionLevel);\n    // Calculate how many blocks each group should contain\n    var blocksInGroup2 = totalCodewords % ecTotalBlocks;\n    var blocksInGroup1 = ecTotalBlocks - blocksInGroup2;\n    var totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);\n    var dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);\n    var dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;\n    // Number of EC codewords is the same for both groups\n    var ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;\n    // Initialize a Reed-Solomon encoder with a generator polynomial of degree ecCount\n    var rs = new reedSolomonEncoder(ecCount);\n    var offset = 0;\n    var dcData = new Array(ecTotalBlocks);\n    var ecData = new Array(ecTotalBlocks);\n    var maxDataSize = 0;\n    var buffer = typedarrayBuffer.from(bitBuffer.buffer);\n    // Divide the buffer into the required number of blocks\n    for (var b = 0; b < ecTotalBlocks; b++) {\n        var dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;\n        // extract a block of data from buffer\n        dcData[b] = buffer.slice(offset, offset + dataSize);\n        // Calculate EC codewords for this data block\n        ecData[b] = rs.encode(dcData[b]);\n        offset += dataSize;\n        maxDataSize = Math.max(maxDataSize, dataSize);\n    }\n    // Create final data\n    // Interleave the data and error correction codewords from each block\n    var data = typedarrayBuffer.alloc(totalCodewords);\n    var index = 0;\n    var i, r;\n    // Add data codewords\n    for (i = 0; i < maxDataSize; i++) {\n        for (r = 0; r < ecTotalBlocks; r++) {\n            if (i < dcData[r].length) {\n                data[index++] = dcData[r][i];\n            }\n        }\n    }\n    // Apped EC codewords\n    for (i = 0; i < ecCount; i++) {\n        for (r = 0; r < ecTotalBlocks; r++) {\n            data[index++] = ecData[r][i];\n        }\n    }\n    return data;\n}\n/**\n * Build QR Code symbol\n *\n * @param  {String} data                 Input string\n * @param  {Number} version              QR Code version\n * @param  {ErrorCorretionLevel} errorCorrectionLevel Error level\n * @param  {MaskPattern} maskPattern     Mask pattern\n * @return {Object}                      Object containing symbol data\n */\nfunction createSymbol(data, version$1, errorCorrectionLevel, maskPattern$1) {\n    var segments$1;\n    if (isarray(data)) {\n        segments$1 = segments.fromArray(data);\n    }\n    else if (typeof data === 'string') {\n        var estimatedVersion = version$1;\n        if (!estimatedVersion) {\n            var rawSegments = segments.rawSplit(data);\n            // Estimate best version that can contain raw splitted segments\n            estimatedVersion = version.getBestVersionForData(rawSegments, errorCorrectionLevel);\n        }\n        // Build optimized segments\n        // If estimated version is undefined, try with the highest version\n        segments$1 = segments.fromString(data, estimatedVersion || 40);\n    }\n    else {\n        throw new Error('Invalid data');\n    }\n    // Get the min version that can contain data\n    var bestVersion = version.getBestVersionForData(segments$1, errorCorrectionLevel);\n    // If no version is found, data cannot be stored\n    if (!bestVersion) {\n        throw new Error('The amount of data is too big to be stored in a QR Code');\n    }\n    // If not specified, use min version as default\n    if (!version$1) {\n        version$1 = bestVersion;\n        // Check if the specified version can contain the data\n    }\n    else if (version$1 < bestVersion) {\n        throw new Error('\\n' +\n            'The chosen QR Code version cannot contain this amount of data.\\n' +\n            'Minimum version required to store current data is: ' + bestVersion + '.\\n');\n    }\n    var dataBits = createData(version$1, errorCorrectionLevel, segments$1);\n    // Allocate matrix buffer\n    var moduleCount = utils.getSymbolSize(version$1);\n    var modules = new bitMatrix(moduleCount);\n    // Add function modules\n    setupFinderPattern(modules, version$1);\n    setupTimingPattern(modules);\n    setupAlignmentPattern(modules, version$1);\n    // Add temporary dummy bits for format info just to set them as reserved.\n    // This is needed to prevent these bits from being masked by {@link MaskPattern.applyMask}\n    // since the masking operation must be performed only on the encoding region.\n    // These blocks will be replaced with correct values later in code.\n    setupFormatInfo(modules, errorCorrectionLevel, 0);\n    if (version$1 >= 7) {\n        setupVersionInfo(modules, version$1);\n    }\n    // Add data codewords\n    setupData(modules, dataBits);\n    if (isNaN(maskPattern$1)) {\n        // Find best mask pattern\n        maskPattern$1 = maskPattern.getBestMask(modules, setupFormatInfo.bind(null, modules, errorCorrectionLevel));\n    }\n    // Apply mask pattern\n    maskPattern.applyMask(maskPattern$1, modules);\n    // Replace format info bits with correct values\n    setupFormatInfo(modules, errorCorrectionLevel, maskPattern$1);\n    return {\n        modules: modules,\n        version: version$1,\n        errorCorrectionLevel: errorCorrectionLevel,\n        maskPattern: maskPattern$1,\n        segments: segments$1\n    };\n}\n/**\n * QR Code\n *\n * @param {String | Array} data                 Input data\n * @param {Object} options                      Optional configurations\n * @param {Number} options.version              QR Code version\n * @param {String} options.errorCorrectionLevel Error correction level\n * @param {Function} options.toSJISFunc         Helper func to convert utf8 to sjis\n */\nvar create = function create(data, options) {\n    if (typeof data === 'undefined' || data === '') {\n        throw new Error('No input text');\n    }\n    var errorCorrectionLevel$1 = errorCorrectionLevel.M;\n    var version$1;\n    var mask;\n    if (typeof options !== 'undefined') {\n        // Use higher error correction level as default\n        errorCorrectionLevel$1 = errorCorrectionLevel.from(options.errorCorrectionLevel, errorCorrectionLevel.M);\n        version$1 = version.from(options.version);\n        mask = maskPattern.from(options.maskPattern);\n        if (options.toSJISFunc) {\n            utils.setToSJISFunction(options.toSJISFunc);\n        }\n    }\n    return createSymbol(data, version$1, errorCorrectionLevel$1, mask);\n};\nvar qrcode = {\n    create: create\n};\nvar utils$1 = createCommonjsModule(function (module, exports) {\n    function hex2rgba(hex) {\n        if (typeof hex === 'number') {\n            hex = hex.toString();\n        }\n        if (typeof hex !== 'string') {\n            throw new Error('Color should be defined as hex string');\n        }\n        var hexCode = hex.slice().replace('#', '').split('');\n        if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {\n            throw new Error('Invalid hex color: ' + hex);\n        }\n        // Convert from short to long form (fff -> ffffff)\n        if (hexCode.length === 3 || hexCode.length === 4) {\n            hexCode = Array.prototype.concat.apply([], hexCode.map(function (c) {\n                return [c, c];\n            }));\n        }\n        // Add default alpha value\n        if (hexCode.length === 6)\n            hexCode.push('F', 'F');\n        var hexValue = parseInt(hexCode.join(''), 16);\n        return {\n            r: (hexValue >> 24) & 255,\n            g: (hexValue >> 16) & 255,\n            b: (hexValue >> 8) & 255,\n            a: hexValue & 255,\n            hex: '#' + hexCode.slice(0, 6).join('')\n        };\n    }\n    exports.getOptions = function getOptions(options) {\n        if (!options)\n            options = {};\n        if (!options.color)\n            options.color = {};\n        var margin = typeof options.margin === 'undefined' ||\n            options.margin === null ||\n            options.margin < 0 ? 4 : options.margin;\n        var width = options.width && options.width >= 21 ? options.width : undefined;\n        var scale = options.scale || 4;\n        return {\n            width: width,\n            scale: width ? 4 : scale,\n            margin: margin,\n            color: {\n                dark: hex2rgba(options.color.dark || '#000000ff'),\n                light: hex2rgba(options.color.light || '#ffffffff')\n            },\n            type: options.type,\n            rendererOpts: options.rendererOpts || {}\n        };\n    };\n    exports.getScale = function getScale(qrSize, opts) {\n        return opts.width && opts.width >= qrSize + opts.margin * 2\n            ? opts.width / (qrSize + opts.margin * 2)\n            : opts.scale;\n    };\n    exports.getImageWidth = function getImageWidth(qrSize, opts) {\n        var scale = exports.getScale(qrSize, opts);\n        return Math.floor((qrSize + opts.margin * 2) * scale);\n    };\n    exports.qrToImageData = function qrToImageData(imgData, qr, opts) {\n        var size = qr.modules.size;\n        var data = qr.modules.data;\n        var scale = exports.getScale(size, opts);\n        var symbolSize = Math.floor((size + opts.margin * 2) * scale);\n        var scaledMargin = opts.margin * scale;\n        var palette = [opts.color.light, opts.color.dark];\n        for (var i = 0; i < symbolSize; i++) {\n            for (var j = 0; j < symbolSize; j++) {\n                var posDst = (i * symbolSize + j) * 4;\n                var pxColor = opts.color.light;\n                if (i >= scaledMargin && j >= scaledMargin &&\n                    i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {\n                    var iSrc = Math.floor((i - scaledMargin) / scale);\n                    var jSrc = Math.floor((j - scaledMargin) / scale);\n                    pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];\n                }\n                imgData[posDst++] = pxColor.r;\n                imgData[posDst++] = pxColor.g;\n                imgData[posDst++] = pxColor.b;\n                imgData[posDst] = pxColor.a;\n            }\n        }\n    };\n});\nvar canvas = createCommonjsModule(function (module, exports) {\n    function clearCanvas(ctx, canvas, size) {\n        ctx.clearRect(0, 0, canvas.width, canvas.height);\n        if (!canvas.style)\n            canvas.style = {};\n        canvas.height = size;\n        canvas.width = size;\n        canvas.style.height = size + 'px';\n        canvas.style.width = size + 'px';\n    }\n    function getCanvasElement() {\n        try {\n            return document.createElement('canvas');\n        }\n        catch (e) {\n            throw new Error('You need to specify a canvas element');\n        }\n    }\n    exports.render = function render(qrData, canvas, options) {\n        var opts = options;\n        var canvasEl = canvas;\n        if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {\n            opts = canvas;\n            canvas = undefined;\n        }\n        if (!canvas) {\n            canvasEl = getCanvasElement();\n        }\n        opts = utils$1.getOptions(opts);\n        var size = utils$1.getImageWidth(qrData.modules.size, opts);\n        var ctx = canvasEl.getContext('2d');\n        var image = ctx.createImageData(size, size);\n        utils$1.qrToImageData(image.data, qrData, opts);\n        clearCanvas(ctx, canvasEl, size);\n        ctx.putImageData(image, 0, 0);\n        return canvasEl;\n    };\n    exports.renderToDataURL = function renderToDataURL(qrData, canvas, options) {\n        var opts = options;\n        if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {\n            opts = canvas;\n            canvas = undefined;\n        }\n        if (!opts)\n            opts = {};\n        var canvasEl = exports.render(qrData, canvas, opts);\n        var type = opts.type || 'image/png';\n        var rendererOpts = opts.rendererOpts || {};\n        return canvasEl.toDataURL(type, rendererOpts.quality);\n    };\n});\nfunction getColorAttrib(color, attrib) {\n    var alpha = color.a / 255;\n    var str = attrib + '=\"' + color.hex + '\"';\n    return alpha < 1\n        ? str + ' ' + attrib + '-opacity=\"' + alpha.toFixed(2).slice(1) + '\"'\n        : str;\n}\nfunction svgCmd(cmd, x, y) {\n    var str = cmd + x;\n    if (typeof y !== 'undefined')\n        str += ' ' + y;\n    return str;\n}\nfunction qrToPath(data, size, margin) {\n    var path = '';\n    var moveBy = 0;\n    var newRow = false;\n    var lineLength = 0;\n    for (var i = 0; i < data.length; i++) {\n        var col = Math.floor(i % size);\n        var row = Math.floor(i / size);\n        if (!col && !newRow)\n            newRow = true;\n        if (data[i]) {\n            lineLength++;\n            if (!(i > 0 && col > 0 && data[i - 1])) {\n                path += newRow\n                    ? svgCmd('M', col + margin, 0.5 + row + margin)\n                    : svgCmd('m', moveBy, 0);\n                moveBy = 0;\n                newRow = false;\n            }\n            if (!(col + 1 < size && data[i + 1])) {\n                path += svgCmd('h', lineLength);\n                lineLength = 0;\n            }\n        }\n        else {\n            moveBy++;\n        }\n    }\n    return path;\n}\nvar render = function render(qrData, options, cb) {\n    var opts = utils$1.getOptions(options);\n    var size = qrData.modules.size;\n    var data = qrData.modules.data;\n    var qrcodesize = size + opts.margin * 2;\n    var bg = !opts.color.light.a\n        ? ''\n        : '<path ' + getColorAttrib(opts.color.light, 'fill') +\n            ' d=\"M0 0h' + qrcodesize + 'v' + qrcodesize + 'H0z\"/>';\n    var path = '<path ' + getColorAttrib(opts.color.dark, 'stroke') +\n        ' d=\"' + qrToPath(data, size, opts.margin) + '\"/>';\n    var viewBox = 'viewBox=\"' + '0 0 ' + qrcodesize + ' ' + qrcodesize + '\"';\n    var width = !opts.width ? '' : 'width=\"' + opts.width + '\" height=\"' + opts.width + '\" ';\n    var svgTag = '<svg xmlns=\"http://www.w3.org/2000/svg\" ' + width + viewBox + ' shape-rendering=\"crispEdges\">' + bg + path + '</svg>\\n';\n    if (typeof cb === 'function') {\n        cb(null, svgTag);\n    }\n    return svgTag;\n};\nvar svgTag = {\n    render: render\n};\nfunction renderCanvas(renderFunc, canvas, text, opts, cb) {\n    var args = [].slice.call(arguments, 1);\n    var argsNum = args.length;\n    var isLastArgCb = typeof args[argsNum - 1] === 'function';\n    if (!isLastArgCb && !canPromise()) {\n        throw new Error('Callback required as last argument');\n    }\n    if (isLastArgCb) {\n        if (argsNum < 2) {\n            throw new Error('Too few arguments provided');\n        }\n        if (argsNum === 2) {\n            cb = text;\n            text = canvas;\n            canvas = opts = undefined;\n        }\n        else if (argsNum === 3) {\n            if (canvas.getContext && typeof cb === 'undefined') {\n                cb = opts;\n                opts = undefined;\n            }\n            else {\n                cb = opts;\n                opts = text;\n                text = canvas;\n                canvas = undefined;\n            }\n        }\n    }\n    else {\n        if (argsNum < 1) {\n            throw new Error('Too few arguments provided');\n        }\n        if (argsNum === 1) {\n            text = canvas;\n            canvas = opts = undefined;\n        }\n        else if (argsNum === 2 && !canvas.getContext) {\n            opts = text;\n            text = canvas;\n            canvas = undefined;\n        }\n        return new Promise(function (resolve, reject) {\n            try {\n                var data = qrcode.create(text, opts);\n                resolve(renderFunc(data, canvas, opts));\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n    try {\n        var data = qrcode.create(text, opts);\n        cb(null, renderFunc(data, canvas, opts));\n    }\n    catch (e) {\n        cb(e);\n    }\n}\nvar create$1 = qrcode.create;\nvar toCanvas = renderCanvas.bind(null, canvas.render);\nvar toDataURL = renderCanvas.bind(null, canvas.renderToDataURL);\n// only svg for now.\nvar toString_1 = renderCanvas.bind(null, function (data, _, opts) {\n    return svgTag.render(data, opts);\n});\nvar browser = {\n    create: create$1,\n    toCanvas: toCanvas,\n    toDataURL: toDataURL,\n    toString: toString_1\n};\nvar amplifyTotpSetupCss = \".totp-setup{text-align:center;margin-bottom:30px}.totp-setup img{height:128px;width:128px}\";\nvar logger = new Logger('TOTP');\nvar AmplifyTOTPSetup = /** @class */ (function () {\n    function class_1(hostRef) {\n        registerInstance(this, hostRef);\n        this.inputProps = {\n            autoFocus: true,\n        };\n        /** Auth state change handler for this component */\n        this.handleAuthStateChange = dispatchAuthStateChangeEvent;\n        /** Used for header text in totp setup component */\n        this.headerText = Translations.TOTP_HEADER_TEXT;\n        /** Used for customizing the issuer string in the qr code image */\n        this.issuer = Translations.TOTP_ISSUER;\n        this.code = null;\n        this.setupMessage = null;\n        this.qrCodeInput = null;\n        this.loading = false;\n    }\n    class_1.prototype.componentWillLoad = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var _this = this;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        /**\n                         * We didn't use `@Watch` here because it doesn't fire when we go from require-new-password to totp-setup.\n                         * That is because `Auth.completeNewPassword` only changes `user` in place and Watch doesn't detect changes\n                         * unless we make a clone.\n                         */\n                        this.removeHubListener = onAuthUIStateChange(function (authState) {\n                            if (authState === AuthState.TOTPSetup)\n                                _this.setup();\n                        });\n                        return [4 /*yield*/, this.setup()];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    class_1.prototype.disconnectedCallback = function () {\n        this.removeHubListener && this.removeHubListener(); // stop listening to `onAuthUIStateChange`\n    };\n    class_1.prototype.buildOtpAuthPath = function (user, issuer, secretKey) {\n        return \"otpauth://totp/\" + issuer + \":\" + user.username + \"?secret=\" + secretKey + \"&issuer=\" + issuer;\n    };\n    class_1.prototype.onTOTPEvent = function (event, data, user) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        logger.debug('on totp event', event, data);\n                        if (!(event === SETUP_TOTP && data === SUCCESS)) return [3 /*break*/, 2];\n                        return [4 /*yield*/, checkContact(user, this.handleAuthStateChange)];\n                    case 1:\n                        _a.sent();\n                        _a.label = 2;\n                    case 2: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    class_1.prototype.handleTotpInputChange = function (event) {\n        this.setupMessage = null;\n        this.qrCodeInput = event.target.value;\n    };\n    class_1.prototype.generateQRCode = function (codeFromTotp) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, error_1;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        _b.trys.push([0, 2, , 3]);\n                        _a = this;\n                        return [4 /*yield*/, browser.toDataURL(codeFromTotp)];\n                    case 1:\n                        _a.qrCodeImageSource = _b.sent();\n                        return [3 /*break*/, 3];\n                    case 2:\n                        error_1 = _b.sent();\n                        dispatchToastHubEvent(error_1);\n                        return [3 /*break*/, 3];\n                    case 3: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    class_1.prototype.setup = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var encodedIssuer, secretKey, error_2;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        // ensure setup is only run once after totp setup is available\n                        if (!this.user || this.user.challengeName !== 'MFA_SETUP' || this.loading)\n                            return [2 /*return*/];\n                        this.setupMessage = null;\n                        encodedIssuer = encodeURI(I18n.get(this.issuer));\n                        if (!Auth || typeof Auth.setupTOTP !== 'function') {\n                            throw new Error(NO_AUTH_MODULE_FOUND);\n                        }\n                        this.loading = true;\n                        _a.label = 1;\n                    case 1:\n                        _a.trys.push([1, 3, 4, 5]);\n                        return [4 /*yield*/, Auth.setupTOTP(this.user)];\n                    case 2:\n                        secretKey = _a.sent();\n                        logger.debug('secret key', secretKey);\n                        this.code = this.buildOtpAuthPath(this.user, encodedIssuer, secretKey);\n                        this.generateQRCode(this.code);\n                        return [3 /*break*/, 5];\n                    case 3:\n                        error_2 = _a.sent();\n                        dispatchToastHubEvent(error_2);\n                        logger.debug(I18n.get(Translations.TOTP_SETUP_FAILURE), error_2);\n                        return [3 /*break*/, 5];\n                    case 4:\n                        this.loading = false;\n                        return [7 /*endfinally*/];\n                    case 5: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    class_1.prototype.verifyTotpToken = function (event) {\n        return __awaiter(this, void 0, void 0, function () {\n            var user, error_3;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (event) {\n                            event.preventDefault();\n                        }\n                        if (!this.qrCodeInput) {\n                            logger.debug('No TOTP Code provided');\n                            return [2 /*return*/];\n                        }\n                        user = this.user;\n                        if (!Auth || typeof Auth.verifyTotpToken !== 'function' || typeof Auth.setPreferredMFA !== 'function') {\n                            throw new Error(NO_AUTH_MODULE_FOUND);\n                        }\n                        _a.label = 1;\n                    case 1:\n                        _a.trys.push([1, 5, , 6]);\n                        return [4 /*yield*/, Auth.verifyTotpToken(user, this.qrCodeInput)];\n                    case 2:\n                        _a.sent();\n                        return [4 /*yield*/, Auth.setPreferredMFA(user, MfaOption.TOTP)];\n                    case 3:\n                        _a.sent();\n                        this.setupMessage = I18n.get(Translations.TOTP_SUCCESS_MESSAGE);\n                        logger.debug(I18n.get(Translations.TOTP_SUCCESS_MESSAGE));\n                        return [4 /*yield*/, this.onTOTPEvent(SETUP_TOTP, SUCCESS, user)];\n                    case 4:\n                        _a.sent();\n                        return [3 /*break*/, 6];\n                    case 5:\n                        error_3 = _a.sent();\n                        this.setupMessage = I18n.get(Translations.TOTP_SETUP_FAILURE);\n                        logger.error(error_3);\n                        return [3 /*break*/, 6];\n                    case 6: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    class_1.prototype.render = function () {\n        var _this = this;\n        return (h(Host, null, h(\"amplify-form-section\", { headerText: I18n.get(this.headerText), submitButtonText: I18n.get(Translations.TOTP_SUBMIT_BUTTON_TEXT), handleSubmit: function (event) { return _this.verifyTotpToken(event); }, loading: this.loading }, h(\"div\", { class: \"totp-setup\" }, this.qrCodeImageSource && h(\"img\", { src: this.qrCodeImageSource, alt: I18n.get(Translations.QR_CODE_ALT) }), h(\"amplify-form-field\", { label: I18n.get(Translations.TOTP_LABEL), inputProps: this.inputProps, fieldId: \"totpCode\", name: \"totpCode\", handleInputChange: function (event) { return _this.handleTotpInputChange(event); } })))));\n    };\n    return class_1;\n}());\nAmplifyTOTPSetup.style = amplifyTotpSetupCss;\nexport { AmplifyRadioButton as amplify_radio_button, AmplifyTOTPSetup as amplify_totp_setup };\n"],"sourceRoot":""}