{"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 \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 : '';\n var path = '';\n var viewBox = 'viewBox=\"' + '0 0 ' + qrcodesize + ' ' + qrcodesize + '\"';\n var width = !opts.width ? '' : 'width=\"' + opts.width + '\" height=\"' + opts.width + '\" ';\n var svgTag = '' + bg + path + '\\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":""}