web3privacy/w3ps1
1
0
Fork 0
mirror of https://github.com/web3privacy/w3ps1.git synced 2024-10-15 16:26:26 +02:00
Code Issues Projects Releases Packages Wiki Activity
w3ps1/_app/immutable/chunks/index-d9aacd03.js

10908 lines
340 KiB
JavaScript
Raw Normal View History

deploy: 8dd2339f904ec479aa186cf141f2b7cfb1812d6a
2023-04-25 08:25:58 +02:00
import { r as require$$1, e as commonjsGlobal, s as sha3Exports, h as getAugmentedNamespace, l as base64Js, m as ieee754, E as EventEmitter } from "./_page-88d93b16.js";
import { p as payloadId$1, s as splitOnFirst, a as strictUriEncode, d as decodeUriComponent, c as cjs$3, I as IJsonRpcConnection, f as formatJsonRpcError, J as JsonRpcProvider, H as HttpConnection } from "./index-5525e91d.js";
deploy: bb3194dce74e8b72735bd06eab28a145d5f7b5a7
2023-02-27 07:03:31 +01:00
import { d as dijkstraExports } from "./dijkstra-cb1f074b.js";
var cjs$2 = {};
var cjs$1 = {};
Object.defineProperty(cjs$1, "__esModule", { value: true });
var getLocalStorage_1 = cjs$1.getLocalStorage = getLocalStorageOrThrow_1 = cjs$1.getLocalStorageOrThrow = getCrypto_1 = cjs$1.getCrypto = getCryptoOrThrow_1 = cjs$1.getCryptoOrThrow = getLocation_1 = cjs$1.getLocation = getLocationOrThrow_1 = cjs$1.getLocationOrThrow = getNavigator_1 = cjs$1.getNavigator = getNavigatorOrThrow_1 = cjs$1.getNavigatorOrThrow = getDocument_1 = cjs$1.getDocument = getDocumentOrThrow_1 = cjs$1.getDocumentOrThrow = getFromWindowOrThrow_1 = cjs$1.getFromWindowOrThrow = getFromWindow_1 = cjs$1.getFromWindow = void 0;
function getFromWindow$1(name) {
let res = void 0;
if (typeof window !== "undefined" && typeof window[name] !== "undefined") {
res = window[name];
}
return res;
}
var getFromWindow_1 = cjs$1.getFromWindow = getFromWindow$1;
function getFromWindowOrThrow$1(name) {
const res = getFromWindow$1(name);
if (!res) {
throw new Error(`${name} is not defined in Window`);
}
return res;
}
var getFromWindowOrThrow_1 = cjs$1.getFromWindowOrThrow = getFromWindowOrThrow$1;
function getDocumentOrThrow$1() {
return getFromWindowOrThrow$1("document");
}
var getDocumentOrThrow_1 = cjs$1.getDocumentOrThrow = getDocumentOrThrow$1;
function getDocument$1() {
return getFromWindow$1("document");
}
var getDocument_1 = cjs$1.getDocument = getDocument$1;
function getNavigatorOrThrow$1() {
return getFromWindowOrThrow$1("navigator");
}
var getNavigatorOrThrow_1 = cjs$1.getNavigatorOrThrow = getNavigatorOrThrow$1;
function getNavigator$1() {
return getFromWindow$1("navigator");
}
var getNavigator_1 = cjs$1.getNavigator = getNavigator$1;
function getLocationOrThrow$1() {
return getFromWindowOrThrow$1("location");
}
var getLocationOrThrow_1 = cjs$1.getLocationOrThrow = getLocationOrThrow$1;
function getLocation$1() {
return getFromWindow$1("location");
}
var getLocation_1 = cjs$1.getLocation = getLocation$1;
function getCryptoOrThrow$1() {
return getFromWindowOrThrow$1("crypto");
}
var getCryptoOrThrow_1 = cjs$1.getCryptoOrThrow = getCryptoOrThrow$1;
function getCrypto$1() {
return getFromWindow$1("crypto");
}
var getCrypto_1 = cjs$1.getCrypto = getCrypto$1;
function getLocalStorageOrThrow$1() {
return getFromWindowOrThrow$1("localStorage");
}
var getLocalStorageOrThrow_1 = cjs$1.getLocalStorageOrThrow = getLocalStorageOrThrow$1;
function getLocalStorage$1() {
return getFromWindow$1("localStorage");
}
getLocalStorage_1 = cjs$1.getLocalStorage = getLocalStorage$1;
Object.defineProperty(cjs$2, "__esModule", { value: true });
var getWindowMetadata_1 = cjs$2.getWindowMetadata = void 0;
const window_getters_1 = cjs$1;
function getWindowMetadata() {
let doc;
let loc;
try {
doc = window_getters_1.getDocumentOrThrow();
loc = window_getters_1.getLocationOrThrow();
} catch (e2) {
return null;
}
function getIcons() {
const links = doc.getElementsByTagName("link");
const icons2 = [];
for (let i2 = 0; i2 < links.length; i2++) {
const link = links[i2];
const rel = link.getAttribute("rel");
if (rel) {
if (rel.toLowerCase().indexOf("icon") > -1) {
const href = link.getAttribute("href");
if (href) {
if (href.toLowerCase().indexOf("https:") === -1 && href.toLowerCase().indexOf("http:") === -1 && href.indexOf("//") !== 0) {
let absoluteHref = loc.protocol + "//" + loc.host;
if (href.indexOf("/") === 0) {
absoluteHref += href;
} else {
const path = loc.pathname.split("/");
path.pop();
const finalPath = path.join("/");
absoluteHref += finalPath + "/" + href;
}
icons2.push(absoluteHref);
} else if (href.indexOf("//") === 0) {
const absoluteUrl = loc.protocol + href;
icons2.push(absoluteUrl);
} else {
icons2.push(href);
}
}
}
}
}
return icons2;
}
function getWindowMetadataOfAny(...args) {
const metaTags = doc.getElementsByTagName("meta");
for (let i2 = 0; i2 < metaTags.length; i2++) {
const tag = metaTags[i2];
const attributes = ["itemprop", "property", "name"].map((target) => tag.getAttribute(target)).filter((attr) => {
if (attr) {
return args.includes(attr);
}
return false;
});
if (attributes.length && attributes) {
const content = tag.getAttribute("content");
if (content) {
return content;
}
}
}
return "";
}
function getName() {
let name2 = getWindowMetadataOfAny("name", "og:site_name", "og:title", "twitter:title");
if (!name2) {
name2 = doc.title;
}
return name2;
}
function getDescription() {
const description2 = getWindowMetadataOfAny("description", "og:description", "twitter:description", "keywords");
return description2;
}
const name = getName();
const description = getDescription();
const url = loc.origin;
const icons = getIcons();
const meta = {
description,
url,
icons,
name
};
return meta;
}
getWindowMetadata_1 = cjs$2.getWindowMetadata = getWindowMetadata;
var __spreadArrays = globalThis && globalThis.__spreadArrays || function() {
for (var s2 = 0, i2 = 0, il = arguments.length; i2 < il; i2++)
s2 += arguments[i2].length;
for (var r2 = Array(s2), k2 = 0, i2 = 0; i2 < il; i2++)
for (var a2 = arguments[i2], j2 = 0, jl = a2.length; j2 < jl; j2++, k2++)
r2[k2] = a2[j2];
return r2;
};
var BrowserInfo = (
/** @class */
function() {
function BrowserInfo2(name, version2, os) {
this.name = name;
this.version = version2;
this.os = os;
this.type = "browser";
}
return BrowserInfo2;
}()
);
var NodeInfo = (
/** @class */
function() {
function NodeInfo2(version2) {
this.version = version2;
this.type = "node";
this.name = "node";
this.os = process.platform;
}
return NodeInfo2;
}()
);
var SearchBotDeviceInfo = (
/** @class */
function() {
function SearchBotDeviceInfo2(name, version2, os, bot) {
this.name = name;
this.version = version2;
this.os = os;
this.bot = bot;
this.type = "bot-device";
}
return SearchBotDeviceInfo2;
}()
);
var BotInfo = (
/** @class */
function() {
function BotInfo2() {
this.type = "bot";
this.bot = true;
this.name = "bot";
this.version = null;
this.os = null;
}
return BotInfo2;
}()
);
var ReactNativeInfo = (
/** @class */
function() {
function ReactNativeInfo2() {
this.type = "react-native";
this.name = "react-native";
this.version = null;
this.os = null;
}
return ReactNativeInfo2;
}()
);
var SEARCHBOX_UA_REGEX = /alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/;
var SEARCHBOT_OS_REGEX = /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask\ Jeeves\/Teoma|ia_archiver)/;
var REQUIRED_VERSION_PARTS = 3;
var userAgentRules = [
["aol", /AOLShield\/([0-9\._]+)/],
["edge", /Edge\/([0-9\._]+)/],
["edge-ios", /EdgiOS\/([0-9\._]+)/],
["yandexbrowser", /YaBrowser\/([0-9\._]+)/],
["kakaotalk", /KAKAOTALK\s([0-9\.]+)/],
["samsung", /SamsungBrowser\/([0-9\.]+)/],
["silk", /\bSilk\/([0-9._-]+)\b/],
["miui", /MiuiBrowser\/([0-9\.]+)$/],
["beaker", /BeakerBrowser\/([0-9\.]+)/],
["edge-chromium", /EdgA?\/([0-9\.]+)/],
[
"chromium-webview",
/(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/
],
["chrome", /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
["phantomjs", /PhantomJS\/([0-9\.]+)(:?\s|$)/],
["crios", /CriOS\/([0-9\.]+)(:?\s|$)/],
["firefox", /Firefox\/([0-9\.]+)(?:\s|$)/],
["fxios", /FxiOS\/([0-9\.]+)/],
["opera-mini", /Opera Mini.*Version\/([0-9\.]+)/],
["opera", /Opera\/([0-9\.]+)(?:\s|$)/],
["opera", /OPR\/([0-9\.]+)(:?\s|$)/],
["ie", /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
["ie", /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
["ie", /MSIE\s(7\.0)/],
["bb10", /BB10;\sTouch.*Version\/([0-9\.]+)/],
["android", /Android\s([0-9\.]+)/],
["ios", /Version\/([0-9\._]+).*Mobile.*Safari.*/],
["safari", /Version\/([0-9\._]+).*Safari/],
["facebook", /FBAV\/([0-9\.]+)/],
["instagram", /Instagram\s([0-9\.]+)/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Mobile/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
["searchbot", SEARCHBOX_UA_REGEX]
];
var operatingSystemRules = [
["iOS", /iP(hone|od|ad)/],
["Android OS", /Android/],
["BlackBerry OS", /BlackBerry|BB10/],
["Windows Mobile", /IEMobile/],
["Amazon OS", /Kindle/],
["Windows 3.11", /Win16/],
["Windows 95", /(Windows 95)|(Win95)|(Windows_95)/],
["Windows 98", /(Windows 98)|(Win98)/],
["Windows 2000", /(Windows NT 5.0)|(Windows 2000)/],
["Windows XP", /(Windows NT 5.1)|(Windows XP)/],
["Windows Server 2003", /(Windows NT 5.2)/],
["Windows Vista", /(Windows NT 6.0)/],
["Windows 7", /(Windows NT 6.1)/],
["Windows 8", /(Windows NT 6.2)/],
["Windows 8.1", /(Windows NT 6.3)/],
["Windows 10", /(Windows NT 10.0)/],
["Windows ME", /Windows ME/],
["Open BSD", /OpenBSD/],
["Sun OS", /SunOS/],
["Chrome OS", /CrOS/],
["Linux", /(Linux)|(X11)/],
["Mac OS", /(Mac_PowerPC)|(Macintosh)/],
["QNX", /QNX/],
["BeOS", /BeOS/],
["OS/2", /OS\/2/]
];
function detect(userAgent) {
if (!!userAgent) {
return parseUserAgent(userAgent);
}
if (typeof document === "undefined" && typeof navigator !== "undefined" && navigator.product === "ReactNative") {
return new ReactNativeInfo();
}
if (typeof navigator !== "undefined") {
return parseUserAgent(navigator.userAgent);
}
return getNodeVersion();
}
function matchUserAgent(ua) {
return ua !== "" && userAgentRules.reduce(function(matched, _a) {
var browser2 = _a[0], regex2 = _a[1];
if (matched) {
return matched;
}
var uaMatch = regex2.exec(ua);
return !!uaMatch && [browser2, uaMatch];
}, false);
}
function parseUserAgent(ua) {
var matchedRule = matchUserAgent(ua);
if (!matchedRule) {
return null;
}
var name = matchedRule[0], match = matchedRule[1];
if (name === "searchbot") {
return new BotInfo();
}
var versionParts = match[1] && match[1].split(/[._]/).slice(0, 3);
if (versionParts) {
if (versionParts.length < REQUIRED_VERSION_PARTS) {
versionParts = __spreadArrays(versionParts, createVersionParts(REQUIRED_VERSION_PARTS - versionParts.length));
}
} else {
versionParts = [];
}
var version2 = versionParts.join(".");
var os = detectOS$1(ua);
var searchBotMatch = SEARCHBOT_OS_REGEX.exec(ua);
if (searchBotMatch && searchBotMatch[1]) {
return new SearchBotDeviceInfo(name, version2, os, searchBotMatch[1]);
}
return new BrowserInfo(name, version2, os);
}
function detectOS$1(ua) {
for (var ii = 0, count = operatingSystemRules.length; ii < count; ii++) {
var _a = operatingSystemRules[ii], os = _a[0], regex2 = _a[1];
var match = regex2.exec(ua);
if (match) {
return os;
}
}
return null;
}
function getNodeVersion() {
var isNode2 = typeof process !== "undefined" && process.version;
return isNode2 ? new NodeInfo(process.version.slice(1)) : null;
}
function createVersionParts(count) {
var output = [];
for (var ii = 0; ii < count; ii++) {
output.push("0");
}
return output;
}
function detectEnv(userAgent) {
return detect(userAgent);
}
function detectOS() {
const env = detectEnv();
return env && env.os ? env.os : void 0;
}
function isAndroid() {
const os = detectOS();
return os ? os.toLowerCase().includes("android") : false;
}
function isIOS() {
const os = detectOS();
return os ? os.toLowerCase().includes("ios") || os.toLowerCase().includes("mac") && navigator.maxTouchPoints > 1 : false;
}
function isMobile() {
const os = detectOS();
return os ? isAndroid() || isIOS() : false;
}
function isNode$1() {
const env = detectEnv();
const result = env && env.name ? env.name.toLowerCase() === "node" : false;
return result;
}
function isBrowser() {
const result = !isNode$1() && !!getNavigator();
return result;
}
const getFromWindow = getFromWindow_1;
const getFromWindowOrThrow = getFromWindowOrThrow_1;
const getDocumentOrThrow = getDocumentOrThrow_1;
const getDocument = getDocument_1;
const getNavigatorOrThrow = getNavigatorOrThrow_1;
const getNavigator = getNavigator_1;
const getLocationOrThrow = getLocationOrThrow_1;
const getLocation = getLocation_1;
const getCryptoOrThrow = getCryptoOrThrow_1;
const getCrypto = getCrypto_1;
const getLocalStorageOrThrow = getLocalStorageOrThrow_1;
const getLocalStorage = getLocalStorage_1;
function getClientMeta() {
return getWindowMetadata_1();
}
function safeJsonParse$1(value) {
if (typeof value !== "string") {
throw new Error(`Cannot safe json parse value of type ${typeof value}`);
}
try {
return JSON.parse(value);
} catch (_a) {
return value;
}
}
function safeJsonStringify$1(value) {
return typeof value === "string" ? value : JSON.stringify(value);
}
const safeJsonParse = safeJsonParse$1;
const safeJsonStringify = safeJsonStringify$1;
function setLocal(key, data) {
const raw = safeJsonStringify(data);
const local = getLocalStorage();
if (local) {
local.setItem(key, raw);
}
}
function getLocal(key) {
let data = null;
let raw = null;
const local = getLocalStorage();
if (local) {
raw = local.getItem(key);
}
data = raw ? safeJsonParse(raw) : raw;
return data;
}
function removeLocal(key) {
const local = getLocalStorage();
if (local) {
local.removeItem(key);
}
}
const mobileLinkChoiceKey = "WALLETCONNECT_DEEPLINK_CHOICE";
function formatIOSMobile(uri, entry) {
const encodedUri = encodeURIComponent(uri);
return entry.universalLink ? `${entry.universalLink}/wc?uri=${encodedUri}` : entry.deepLink ? `${entry.deepLink}${entry.deepLink.endsWith(":") ? "//" : "/"}wc?uri=${encodedUri}` : "";
}
function saveMobileLinkInfo(data) {
const focusUri = data.href.split("?")[0];
setLocal(mobileLinkChoiceKey, Object.assign(Object.assign({}, data), { href: focusUri }));
}
function getMobileRegistryEntry(registry, name) {
return registry.filter((entry) => entry.name.toLowerCase().includes(name.toLowerCase()))[0];
}
function getMobileLinkRegistry(registry, whitelist) {
let links = registry;
if (whitelist) {
links = whitelist.map((name) => getMobileRegistryEntry(registry, name)).filter(Boolean);
}
return links;
}
const API_URL = "https://registry.walletconnect.com";
function getWalletRegistryUrl() {
return API_URL + "/api/v2/wallets";
}
function getDappRegistryUrl() {
return API_URL + "/api/v2/dapps";
}
function formatMobileRegistryEntry(entry, platform = "mobile") {
var _a;
return {
name: entry.name || "",
shortName: entry.metadata.shortName || "",
color: entry.metadata.colors.primary || "",
logo: (_a = entry.image_url.sm) !== null && _a !== void 0 ? _a : "",
universalLink: entry[platform].universal || "",
deepLink: entry[platform].native || ""
};
}
function formatMobileRegistry(registry, platform = "mobile") {
return Object.values(registry).filter((entry) => !!entry[platform].universal || !!entry[platform].native).map((entry) => formatMobileRegistryEntry(entry, platform));
}
const esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
__proto__: null,
detectEnv,
detectOS,
formatIOSMobile,
formatMobileRegistry,
formatMobileRegistryEntry,
getClientMeta,
getCrypto,
getCryptoOrThrow,
getDappRegistryUrl,
getDocument,
getDocumentOrThrow,
getFromWindow,
getFromWindowOrThrow,
getLocal,
getLocalStorage,
getLocalStorageOrThrow,
getLocation,
getLocationOrThrow,
getMobileLinkRegistry,
getMobileRegistryEntry,
getNavigator,
getNavigatorOrThrow,
getWalletRegistryUrl,
isAndroid,
isBrowser,
isIOS,
isMobile,
isNode: isNode$1,
mobileLinkChoiceKey,
removeLocal,
safeJsonParse,
safeJsonStringify,
saveMobileLinkInfo,
setLocal
}, Symbol.toStringTag, { value: "Module" }));
const reservedEvents = [
"session_request",
"session_update",
"exchange_key",
"connect",
"disconnect",
"display_uri",
"modal_closed",
"transport_open",
"transport_close",
"transport_error"
];
const signingMethods = [
"eth_sendTransaction",
"eth_signTransaction",
"eth_sign",
"eth_signTypedData",
"eth_signTypedData_v1",
"eth_signTypedData_v2",
"eth_signTypedData_v3",
"eth_signTypedData_v4",
"personal_sign",
"wallet_addEthereumChain",
"wallet_switchEthereumChain",
"wallet_getPermissions",
"wallet_requestPermissions",
"wallet_registerOnboarding",
"wallet_watchAsset",
"wallet_scanQRCode"
];
const infuraNetworks = {
1: "mainnet",
3: "ropsten",
4: "rinkeby",
5: "goerli",
42: "kovan"
};
var bnExports = {};
var bn = {
get exports() {
return bnExports;
},
set exports(v2) {
bnExports = v2;
}
};
(function(module) {
(function(module2, exports) {
function assert(val, msg) {
if (!val)
throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN2(number, base, endian) {
if (BN2.isBN(number)) {
return number;
}
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module2 === "object") {
module2.exports = BN2;
} else {
exports.BN = BN2;
}
BN2.BN = BN2;
BN2.wordSize = 26;
var Buffer2;
try {
Buffer2 = require$$1.Buffer;
} catch (e2) {
}
BN2.isBN = function isBN(num) {
if (num instanceof BN2) {
return true;
}
return num !== null && typeof num === "object" && num.constructor.wordSize === BN2.wordSize && Array.isArray(num.words);
};
BN2.max = function max(left, right) {
if (left.cmp(right) > 0)
return left;
return right;
};
BN2.min = function min(left, right) {
if (left.cmp(right) < 0)
return left;
return right;
};
BN2.prototype._init = function init(number, base, endian) {
if (typeof number === "number") {
return this._initNumber(number, base, endian);
}
if (typeof number === "object") {
return this._initArray(number, base, endian);
}
if (base === "hex") {
base = 16;
}
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
}
if (base === 16) {
this._parseHex(number, start);
} else {
this._parseBase(number, base, start);
}
if (number[0] === "-") {
this.negative = 1;
}
this.strip();
if (endian !== "le")
return;
this._initArray(this.toArray(), base, endian);
};
BN2.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [
number & 67108863,
number / 67108864 & 67108863
];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le")
return;
this._initArray(this.toArray(), base, endian);
};
BN2.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var i2 = 0; i2 < this.length; i2++) {
this.words[i2] = 0;
}
var j2, w2;
var off = 0;
if (endian === "be") {
for (i2 = number.length - 1, j2 = 0; i2 >= 0; i2 -= 3) {
w2 = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16;
this.words[j2] |= w2 << off & 67108863;
this.words[j2 + 1] = w2 >>> 26 - off & 67108863;
off += 24;
if (off >= 26) {
off -= 26;
j2++;
}
}
} else if (endian === "le") {
for (i2 = 0, j2 = 0; i2 < number.length; i2 += 3) {
w2 = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16;
this.words[j2] |= w2 << off & 67108863;
this.words[j2 + 1] = w2 >>> 26 - off & 67108863;
off += 24;
if (off >= 26) {
off -= 26;
j2++;
}
}
}
return this.strip();
};
function parseHex(str, start, end) {
var r2 = 0;
var len = Math.min(str.length, end);
for (var i2 = start; i2 < len; i2++) {
var c2 = str.charCodeAt(i2) - 48;
r2 <<= 4;
if (c2 >= 49 && c2 <= 54) {
r2 |= c2 - 49 + 10;
} else if (c2 >= 17 && c2 <= 22) {
r2 |= c2 - 17 + 10;
} else {
r2 |= c2 & 15;
}
}
return r2;
}
BN2.prototype._parseHex = function _parseHex(number, start) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var i2 = 0; i2 < this.length; i2++) {
this.words[i2] = 0;
}
var j2, w2;
var off = 0;
for (i2 = number.length - 6, j2 = 0; i2 >= start; i2 -= 6) {
w2 = parseHex(number, i2, i2 + 6);
this.words[j2] |= w2 << off & 67108863;
this.words[j2 + 1] |= w2 >>> 26 - off & 4194303;
off += 24;
if (off >= 26) {
off -= 26;
j2++;
}
}
if (i2 + 6 !== start) {
w2 = parseHex(number, start, i2 + 6);
this.words[j2] |= w2 << off & 67108863;
this.words[j2 + 1] |= w2 >>> 26 - off & 4194303;
}
this.strip();
};
function parseBase(str, start, end, mul2) {
var r2 = 0;
var len = Math.min(str.length, end);
for (var i2 = start; i2 < len; i2++) {
var c2 = str.charCodeAt(i2) - 48;
r2 *= mul2;
if (c2 >= 49) {
r2 += c2 - 49 + 10;
} else if (c2 >= 17) {
r2 += c2 - 17 + 10;
} else {
r2 += c2;
}
}
return r2;
}
BN2.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
limbLen++;
}
limbLen--;
limbPow = limbPow / base | 0;
var total = number.length - start;
var mod = total % limbLen;
var end = Math.min(total, total - mod) + start;
var word = 0;
for (var i2 = start; i2 < end; i2 += limbLen) {
word = parseBase(number, i2, i2 + limbLen, base);
this.imuln(limbPow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
if (mod !== 0) {
var pow = 1;
word = parseBase(number, i2, number.length, base);
for (i2 = 0; i2 < mod; i2++) {
pow *= base;
}
this.imuln(pow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
};
BN2.prototype.copy = function copy3(dest) {
dest.words = new Array(this.length);
for (var i2 = 0; i2 < this.length; i2++) {
dest.words[i2] = this.words[i2];
}
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN2.prototype.clone = function clone() {
var r2 = new BN2(null);
this.copy(r2);
return r2;
};
BN2.prototype._expand = function _expand(size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
};
BN2.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this._normSign();
};
BN2.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) {
this.negative = 0;
}
return this;
};
BN2.prototype.inspect = function inspect() {
return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
};
var zeros = [
"",
"0",
"00",
"000",
"0000",
"00000",
"000000",
"0000000",
"00000000",
"000000000",
"0000000000",
"00000000000",
"000000000000",
"0000000000000",
"00000000000000",
"000000000000000",
"0000000000000000",
"00000000000000000",
"000000000000000000",
"0000000000000000000",
"00000000000000000000",
"000000000000000000000",
"0000000000000000000000",
"00000000000000000000000",
"000000000000000000000000",
"0000000000000000000000000"
];
var groupSizes = [
0,
0,
25,
16,
12,
11,
10,
9,
8,
8,
7,
7,
7,
7,
6,
6,
6,
6,
6,
6,
6,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5
];
var groupBases = [
0,
0,
33554432,
43046721,
16777216,
48828125,
60466176,
40353607,
16777216,
43046721,
1e7,
19487171,
35831808,
62748517,
7529536,
11390625,
16777216,
24137569,
34012224,
47045881,
64e6,
4084101,
5153632,
6436343,
7962624,
9765625,
11881376,
14348907,
17210368,
20511149,
243e5,
28629151,
33554432,
39135393,
45435424,
52521875,
60466176
];
BN2.prototype.toString = function toString2(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "hex") {
out = "";
var off = 0;
var carry = 0;
for (var i2 = 0; i2 < this.length; i2++) {
var w2 = this.words[i2];
var word = ((w2 << off | carry) & 16777215).toString(16);
carry = w2 >>> 24 - off & 16777215;
if (carry !== 0 || i2 !== this.length - 1) {
out = zeros[6 - word.length] + word + out;
} else {
out = word + out;
}
off += 2;
if (off >= 26) {
off -= 26;
i2--;
}
}
if (carry !== 0) {
out = carry.toString(16) + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
if (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c2 = this.clone();
c2.negative = 0;
while (!c2.isZero()) {
var r2 = c2.modn(groupBase).toString(base);
c2 = c2.idivn(groupBase);
if (!c2.isZero()) {
out = zeros[groupSize - r2.length] + r2 + out;
} else {
out = r2 + out;
}
}
if (this.isZero()) {
out = "0" + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN2.prototype.toNumber = function toNumber() {
var ret = this.words[0];
if (this.length === 2) {
ret += this.words[1] * 67108864;
} else if (this.length === 3 && this.words[2] === 1) {
ret += 4503599627370496 + this.words[1] * 67108864;
} else if (this.length > 2) {
assert(false, "Number can only safely store up to 53 bits");
}
return this.negative !== 0 ? -ret : ret;
};
BN2.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN2.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer2 !== "undefined");
return this.toArrayLike(Buffer2, endian, length);
};
BN2.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN2.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength2 = this.byteLength();
var reqLength = length || Math.max(1, byteLength2);
assert(byteLength2 <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b2, i2;
var q2 = this.clone();
if (!littleEndian) {
for (i2 = 0; i2 < reqLength - byteLength2; i2++) {
res[i2] = 0;
}
for (i2 = 0; !q2.isZero(); i2++) {
b2 = q2.andln(255);
q2.iushrn(8);
res[reqLength - i2 - 1] = b2;
}
} else {
for (i2 = 0; !q2.isZero(); i2++) {
b2 = q2.andln(255);
q2.iushrn(8);
res[i2] = b2;
}
for (; i2 < reqLength; i2++) {
res[i2] = 0;
}
}
return res;
};
if (Math.clz32) {
BN2.prototype._countBits = function _countBits(w2) {
return 32 - Math.clz32(w2);
};
} else {
BN2.prototype._countBits = function _countBits(w2) {
var t2 = w2;
var r2 = 0;
if (t2 >= 4096) {
r2 += 13;
t2 >>>= 13;
}
if (t2 >= 64) {
r2 += 7;
t2 >>>= 7;
}
if (t2 >= 8) {
r2 += 4;
t2 >>>= 4;
}
if (t2 >= 2) {
r2 += 2;
t2 >>>= 2;
}
return r2 + t2;
};
}
BN2.prototype._zeroBits = function _zeroBits(w2) {
if (w2 === 0)
return 26;
var t2 = w2;
var r2 = 0;
if ((t2 & 8191) === 0) {
r2 += 13;
t2 >>>= 13;
}
if ((t2 & 127) === 0) {
r2 += 7;
t2 >>>= 7;
}
if ((t2 & 15) === 0) {
r2 += 4;
t2 >>>= 4;
}
if ((t2 & 3) === 0) {
r2 += 2;
t2 >>>= 2;
}
if ((t2 & 1) === 0) {
r2++;
}
return r2;
};
BN2.prototype.bitLength = function bitLength() {
var w2 = this.words[this.length - 1];
var hi = this._countBits(w2);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w2 = new Array(num.bitLength());
for (var bit = 0; bit < w2.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w2[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w2;
}
BN2.prototype.zeroBits = function zeroBits() {
if (this.isZero())
return 0;
var r2 = 0;
for (var i2 = 0; i2 < this.length; i2++) {
var b2 = this._zeroBits(this.words[i2]);
r2 += b2;
if (b2 !== 26)
break;
}
return r2;
};
BN2.prototype.byteLength = function byteLength2() {
return Math.ceil(this.bitLength() / 8);
};
BN2.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
};
BN2.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
};
BN2.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN2.prototype.neg = function neg() {
return this.clone().ineg();
};
BN2.prototype.ineg = function ineg() {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
};
BN2.prototype.iuor = function iuor(num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (var i2 = 0; i2 < num.length; i2++) {
this.words[i2] = this.words[i2] | num.words[i2];
}
return this.strip();
};
BN2.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN2.prototype.or = function or(num) {
if (this.length > num.length)
return this.clone().ior(num);
return num.clone().ior(this);
};
BN2.prototype.uor = function uor(num) {
if (this.length > num.length)
return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN2.prototype.iuand = function iuand(num) {
var b2;
if (this.length > num.length) {
b2 = num;
} else {
b2 = this;
}
for (var i2 = 0; i2 < b2.length; i2++) {
this.words[i2] = this.words[i2] & num.words[i2];
}
this.length = b2.length;
return this.strip();
};
BN2.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN2.prototype.and = function and(num) {
if (this.length > num.length)
return this.clone().iand(num);
return num.clone().iand(this);
};
BN2.prototype.uand = function uand(num) {
if (this.length > num.length)
return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN2.prototype.iuxor = function iuxor(num) {
var a2;
var b2;
if (this.length > num.length) {
a2 = this;
b2 = num;
} else {
a2 = num;
b2 = this;
}
for (var i2 = 0; i2 < b2.length; i2++) {
this.words[i2] = a2.words[i2] ^ b2.words[i2];
}
if (this !== a2) {
for (; i2 < a2.length; i2++) {
this.words[i2] = a2.words[i2];
}
}
this.length = a2.length;
return this.strip();
};
BN2.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN2.prototype.xor = function xor(num) {
if (this.length > num.length)
return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN2.prototype.uxor = function uxor(num) {
if (this.length > num.length)
return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN2.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) {
bytesNeeded--;
}
for (var i2 = 0; i2 < bytesNeeded; i2++) {
this.words[i2] = ~this.words[i2] & 67108863;
}
if (bitsLeft > 0) {
this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft;
}
return this.strip();
};
BN2.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN2.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) {
this.words[off] = this.words[off] | 1 << wbit;
} else {
this.words[off] = this.words[off] & ~(1 << wbit);
}
return this.strip();
};
BN2.prototype.iadd = function iadd(num) {
var r2;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r2 = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r2 = this.isub(num);
num.negative = 1;
return r2._normSign();
}
var a2, b2;
if (this.length > num.length) {
a2 = this;
b2 = num;
} else {
a2 = num;
b2 = this;
}
var carry = 0;
for (var i2 = 0; i2 < b2.length; i2++) {
r2 = (a2.words[i2] | 0) + (b2.words[i2] | 0) + carry;
this.words[i2] = r2 & 67108863;
carry = r2 >>> 26;
}
for (; carry !== 0 && i2 < a2.length; i2++) {
r2 = (a2.words[i2] | 0) + carry;
this.words[i2] = r2 & 67108863;
carry = r2 >>> 26;
}
this.length = a2.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
} else if (a2 !== this) {
for (; i2 < a2.length; i2++) {
this.words[i2] = a2.words[i2];
}
}
return this;
};
BN2.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length)
return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN2.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r2 = this.iadd(num);
num.negative = 1;
return r2._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a2, b2;
if (cmp > 0) {
a2 = this;
b2 = num;
} else {
a2 = num;
b2 = this;
}
var carry = 0;
for (var i2 = 0; i2 < b2.length; i2++) {
r2 = (a2.words[i2] | 0) - (b2.words[i2] | 0) + carry;
carry = r2 >> 26;
this.words[i2] = r2 & 67108863;
}
for (; carry !== 0 && i2 < a2.length; i2++) {
r2 = (a2.words[i2] | 0) + carry;
carry = r2 >> 26;
this.words[i2] = r2 & 67108863;
}
if (carry === 0 && i2 < a2.length && a2 !== this) {
for (; i2 < a2.length; i2++) {
this.words[i2] = a2.words[i2];
}
}
this.length = Math.max(this.length, i2);
if (a2 !== this) {
this.negative = 1;
}
return this.strip();
};
BN2.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a2 = self.words[0] | 0;
var b2 = num.words[0] | 0;
var r2 = a2 * b2;
var lo = r2 & 67108863;
var carry = r2 / 67108864 | 0;
out.words[0] = lo;
for (var k2 = 1; k2 < len; k2++) {
var ncarry = carry >>> 26;
var rword = carry & 67108863;
var maxJ = Math.min(k2, num.length - 1);
for (var j2 = Math.max(0, k2 - self.length + 1); j2 <= maxJ; j2++) {
var i2 = k2 - j2 | 0;
a2 = self.words[i2] | 0;
b2 = num.words[j2] | 0;
r2 = a2 * b2 + rword;
ncarry += r2 / 67108864 | 0;
rword = r2 & 67108863;
}
out.words[k2] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) {
out.words[k2] = carry | 0;
} else {
out.length--;
}
return out.strip();
}
var comb10MulTo = function comb10MulTo2(self, num, out) {
var a2 = self.words;
var b2 = num.words;
var o2 = out.words;
var c2 = 0;
var lo;
var mid;
var hi;
var a0 = a2[0] | 0;
var al0 = a0 & 8191;
var ah0 = a0 >>> 13;
var a1 = a2[1] | 0;
var al1 = a1 & 8191;
var ah1 = a1 >>> 13;
var a22 = a2[2] | 0;
var al2 = a22 & 8191;
var ah2 = a22 >>> 13;
var a3 = a2[3] | 0;
var al3 = a3 & 8191;
var ah3 = a3 >>> 13;
var a4 = a2[4] | 0;
var al4 = a4 & 8191;
var ah4 = a4 >>> 13;
var a5 = a2[5] | 0;
var al5 = a5 & 8191;
var ah5 = a5 >>> 13;
var a6 = a2[6] | 0;
var al6 = a6 & 8191;
var ah6 = a6 >>> 13;
var a7 = a2[7] | 0;
var al7 = a7 & 8191;
var ah7 = a7 >>> 13;
var a8 = a2[8] | 0;
var al8 = a8 & 8191;
var ah8 = a8 >>> 13;
var a9 = a2[9] | 0;
var al9 = a9 & 8191;
var ah9 = a9 >>> 13;
var b0 = b2[0] | 0;
var bl0 = b0 & 8191;
var bh0 = b0 >>> 13;
var b1 = b2[1] | 0;
var bl1 = b1 & 8191;
var bh1 = b1 >>> 13;
var b22 = b2[2] | 0;
var bl2 = b22 & 8191;
var bh2 = b22 >>> 13;
var b3 = b2[3] | 0;
var bl3 = b3 & 8191;
var bh3 = b3 >>> 13;
var b4 = b2[4] | 0;
var bl4 = b4 & 8191;
var bh4 = b4 >>> 13;
var b5 = b2[5] | 0;
var bl5 = b5 & 8191;
var bh5 = b5 >>> 13;
var b6 = b2[6] | 0;
var bl6 = b6 & 8191;
var bh6 = b6 >>> 13;
var b7 = b2[7] | 0;
var bl7 = b7 & 8191;
var bh7 = b7 >>> 13;
var b8 = b2[8] | 0;
var bl8 = b8 & 8191;
var bh8 = b8 >>> 13;
var b9 = b2[9] | 0;
var bl9 = b9 & 8191;
var bh9 = b9 >>> 13;
out.negative = self.negative ^ num.negative;
out.length = 19;
lo = Math.imul(al0, bl0);
mid = Math.imul(al0, bh0);
mid = mid + Math.imul(ah0, bl0) | 0;
hi = Math.imul(ah0, bh0);
var w0 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
w0 &= 67108863;
lo = Math.imul(al1, bl0);
mid = Math.imul(al1, bh0);
mid = mid + Math.imul(ah1, bl0) | 0;
hi = Math.imul(ah1, bh0);
lo = lo + Math.imul(al0, bl1) | 0;
mid = mid + Math.imul(al0, bh1) | 0;
mid = mid + Math.imul(ah0, bl1) | 0;
hi = hi + Math.imul(ah0, bh1) | 0;
var w1 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
w1 &= 67108863;
lo = Math.imul(al2, bl0);
mid = Math.imul(al2, bh0);
mid = mid + Math.imul(ah2, bl0) | 0;
hi = Math.imul(ah2, bh0);
lo = lo + Math.imul(al1, bl1) | 0;
mid = mid + Math.imul(al1, bh1) | 0;
mid = mid + Math.imul(ah1, bl1) | 0;
hi = hi + Math.imul(ah1, bh1) | 0;
lo = lo + Math.imul(al0, bl2) | 0;
mid = mid + Math.imul(al0, bh2) | 0;
mid = mid + Math.imul(ah0, bl2) | 0;
hi = hi + Math.imul(ah0, bh2) | 0;
var w2 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
w2 &= 67108863;
lo = Math.imul(al3, bl0);
mid = Math.imul(al3, bh0);
mid = mid + Math.imul(ah3, bl0) | 0;
hi = Math.imul(ah3, bh0);
lo = lo + Math.imul(al2, bl1) | 0;
mid = mid + Math.imul(al2, bh1) | 0;
mid = mid + Math.imul(ah2, bl1) | 0;
hi = hi + Math.imul(ah2, bh1) | 0;
lo = lo + Math.imul(al1, bl2) | 0;
mid = mid + Math.imul(al1, bh2) | 0;
mid = mid + Math.imul(ah1, bl2) | 0;
hi = hi + Math.imul(ah1, bh2) | 0;
lo = lo + Math.imul(al0, bl3) | 0;
mid = mid + Math.imul(al0, bh3) | 0;
mid = mid + Math.imul(ah0, bl3) | 0;
hi = hi + Math.imul(ah0, bh3) | 0;
var w3 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
w3 &= 67108863;
lo = Math.imul(al4, bl0);
mid = Math.imul(al4, bh0);
mid = mid + Math.imul(ah4, bl0) | 0;
hi = Math.imul(ah4, bh0);
lo = lo + Math.imul(al3, bl1) | 0;
mid = mid + Math.imul(al3, bh1) | 0;
mid = mid + Math.imul(ah3, bl1) | 0;
hi = hi + Math.imul(ah3, bh1) | 0;
lo = lo + Math.imul(al2, bl2) | 0;
mid = mid + Math.imul(al2, bh2) | 0;
mid = mid + Math.imul(ah2, bl2) | 0;
hi = hi + Math.imul(ah2, bh2) | 0;
lo = lo + Math.imul(al1, bl3) | 0;
mid = mid + Math.imul(al1, bh3) | 0;
mid = mid + Math.imul(ah1, bl3) | 0;
hi = hi + Math.imul(ah1, bh3) | 0;
lo = lo + Math.imul(al0, bl4) | 0;
mid = mid + Math.imul(al0, bh4) | 0;
mid = mid + Math.imul(ah0, bl4) | 0;
hi = hi + Math.imul(ah0, bh4) | 0;
var w4 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
w4 &= 67108863;
lo = Math.imul(al5, bl0);
mid = Math.imul(al5, bh0);
mid = mid + Math.imul(ah5, bl0) | 0;
hi = Math.imul(ah5, bh0);
lo = lo + Math.imul(al4, bl1) | 0;
mid = mid + Math.imul(al4, bh1) | 0;
mid = mid + Math.imul(ah4, bl1) | 0;
hi = hi + Math.imul(ah4, bh1) | 0;
lo = lo + Math.imul(al3, bl2) | 0;
mid = mid + Math.imul(al3, bh2) | 0;
mid = mid + Math.imul(ah3, bl2) | 0;
hi = hi + Math.imul(ah3, bh2) | 0;
lo = lo + Math.imul(al2, bl3) | 0;
mid = mid + Math.imul(al2, bh3) | 0;
mid = mid + Math.imul(ah2, bl3) | 0;
hi = hi + Math.imul(ah2, bh3) | 0;
lo = lo + Math.imul(al1, bl4) | 0;
mid = mid + Math.imul(al1, bh4) | 0;
mid = mid + Math.imul(ah1, bl4) | 0;
hi = hi + Math.imul(ah1, bh4) | 0;
lo = lo + Math.imul(al0, bl5) | 0;
mid = mid + Math.imul(al0, bh5) | 0;
mid = mid + Math.imul(ah0, bl5) | 0;
hi = hi + Math.imul(ah0, bh5) | 0;
var w5 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
w5 &= 67108863;
lo = Math.imul(al6, bl0);
mid = Math.imul(al6, bh0);
mid = mid + Math.imul(ah6, bl0) | 0;
hi = Math.imul(ah6, bh0);
lo = lo + Math.imul(al5, bl1) | 0;
mid = mid + Math.imul(al5, bh1) | 0;
mid = mid + Math.imul(ah5, bl1) | 0;
hi = hi + Math.imul(ah5, bh1) | 0;
lo = lo + Math.imul(al4, bl2) | 0;
mid = mid + Math.imul(al4, bh2) | 0;
mid = mid + Math.imul(ah4, bl2) | 0;
hi = hi + Math.imul(ah4, bh2) | 0;
lo = lo + Math.imul(al3, bl3) | 0;
mid = mid + Math.imul(al3, bh3) | 0;
mid = mid + Math.imul(ah3, bl3) | 0;
hi = hi + Math.imul(ah3, bh3) | 0;
lo = lo + Math.imul(al2, bl4) | 0;
mid = mid + Math.imul(al2, bh4) | 0;
mid = mid + Math.imul(ah2, bl4) | 0;
hi = hi + Math.imul(ah2, bh4) | 0;
lo = lo + Math.imul(al1, bl5) | 0;
mid = mid + Math.imul(al1, bh5) | 0;
mid = mid + Math.imul(ah1, bl5) | 0;
hi = hi + Math.imul(ah1, bh5) | 0;
lo = lo + Math.imul(al0, bl6) | 0;
mid = mid + Math.imul(al0, bh6) | 0;
mid = mid + Math.imul(ah0, bl6) | 0;
hi = hi + Math.imul(ah0, bh6) | 0;
var w6 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
w6 &= 67108863;
lo = Math.imul(al7, bl0);
mid = Math.imul(al7, bh0);
mid = mid + Math.imul(ah7, bl0) | 0;
hi = Math.imul(ah7, bh0);
lo = lo + Math.imul(al6, bl1) | 0;
mid = mid + Math.imul(al6, bh1) | 0;
mid = mid + Math.imul(ah6, bl1) | 0;
hi = hi + Math.imul(ah6, bh1) | 0;
lo = lo + Math.imul(al5, bl2) | 0;
mid = mid + Math.imul(al5, bh2) | 0;
mid = mid + Math.imul(ah5, bl2) | 0;
hi = hi + Math.imul(ah5, bh2) | 0;
lo = lo + Math.imul(al4, bl3) | 0;
mid = mid + Math.imul(al4, bh3) | 0;
mid = mid + Math.imul(ah4, bl3) | 0;
hi = hi + Math.imul(ah4, bh3) | 0;
lo = lo + Math.imul(al3, bl4) | 0;
mid = mid + Math.imul(al3, bh4) | 0;
mid = mid + Math.imul(ah3, bl4) | 0;
hi = hi + Math.imul(ah3, bh4) | 0;
lo = lo + Math.imul(al2, bl5) | 0;
mid = mid + Math.imul(al2, bh5) | 0;
mid = mid + Math.imul(ah2, bl5) | 0;
hi = hi + Math.imul(ah2, bh5) | 0;
lo = lo + Math.imul(al1, bl6) | 0;
mid = mid + Math.imul(al1, bh6) | 0;
mid = mid + Math.imul(ah1, bl6) | 0;
hi = hi + Math.imul(ah1, bh6) | 0;
lo = lo + Math.imul(al0, bl7) | 0;
mid = mid + Math.imul(al0, bh7) | 0;
mid = mid + Math.imul(ah0, bl7) | 0;
hi = hi + Math.imul(ah0, bh7) | 0;
var w7 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
w7 &= 67108863;
lo = Math.imul(al8, bl0);
mid = Math.imul(al8, bh0);
mid = mid + Math.imul(ah8, bl0) | 0;
hi = Math.imul(ah8, bh0);
lo = lo + Math.imul(al7, bl1) | 0;
mid = mid + Math.imul(al7, bh1) | 0;
mid = mid + Math.imul(ah7, bl1) | 0;
hi = hi + Math.imul(ah7, bh1) | 0;
lo = lo + Math.imul(al6, bl2) | 0;
mid = mid + Math.imul(al6, bh2) | 0;
mid = mid + Math.imul(ah6, bl2) | 0;
hi = hi + Math.imul(ah6, bh2) | 0;
lo = lo + Math.imul(al5, bl3) | 0;
mid = mid + Math.imul(al5, bh3) | 0;
mid = mid + Math.imul(ah5, bl3) | 0;
hi = hi + Math.imul(ah5, bh3) | 0;
lo = lo + Math.imul(al4, bl4) | 0;
mid = mid + Math.imul(al4, bh4) | 0;
mid = mid + Math.imul(ah4, bl4) | 0;
hi = hi + Math.imul(ah4, bh4) | 0;
lo = lo + Math.imul(al3, bl5) | 0;
mid = mid + Math.imul(al3, bh5) | 0;
mid = mid + Math.imul(ah3, bl5) | 0;
hi = hi + Math.imul(ah3, bh5) | 0;
lo = lo + Math.imul(al2, bl6) | 0;
mid = mid + Math.imul(al2, bh6) | 0;
mid = mid + Math.imul(ah2, bl6) | 0;
hi = hi + Math.imul(ah2, bh6) | 0;
lo = lo + Math.imul(al1, bl7) | 0;
mid = mid + Math.imul(al1, bh7) | 0;
mid = mid + Math.imul(ah1, bl7) | 0;
hi = hi + Math.imul(ah1, bh7) | 0;
lo = lo + Math.imul(al0, bl8) | 0;
mid = mid + Math.imul(al0, bh8) | 0;
mid = mid + Math.imul(ah0, bl8) | 0;
hi = hi + Math.imul(ah0, bh8) | 0;
var w8 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
w8 &= 67108863;
lo = Math.imul(al9, bl0);
mid = Math.imul(al9, bh0);
mid = mid + Math.imul(ah9, bl0) | 0;
hi = Math.imul(ah9, bh0);
lo = lo + Math.imul(al8, bl1) | 0;
mid = mid + Math.imul(al8, bh1) | 0;
mid = mid + Math.imul(ah8, bl1) | 0;
hi = hi + Math.imul(ah8, bh1) | 0;
lo = lo + Math.imul(al7, bl2) | 0;
mid = mid + Math.imul(al7, bh2) | 0;
mid = mid + Math.imul(ah7, bl2) | 0;
hi = hi + Math.imul(ah7, bh2) | 0;
lo = lo + Math.imul(al6, bl3) | 0;
mid = mid + Math.imul(al6, bh3) | 0;
mid = mid + Math.imul(ah6, bl3) | 0;
hi = hi + Math.imul(ah6, bh3) | 0;
lo = lo + Math.imul(al5, bl4) | 0;
mid = mid + Math.imul(al5, bh4) | 0;
mid = mid + Math.imul(ah5, bl4) | 0;
hi = hi + Math.imul(ah5, bh4) | 0;
lo = lo + Math.imul(al4, bl5) | 0;
mid = mid + Math.imul(al4, bh5) | 0;
mid = mid + Math.imul(ah4, bl5) | 0;
hi = hi + Math.imul(ah4, bh5) | 0;
lo = lo + Math.imul(al3, bl6) | 0;
mid = mid + Math.imul(al3, bh6) | 0;
mid = mid + Math.imul(ah3, bl6) | 0;
hi = hi + Math.imul(ah3, bh6) | 0;
lo = lo + Math.imul(al2, bl7) | 0;
mid = mid + Math.imul(al2, bh7) | 0;
mid = mid + Math.imul(ah2, bl7) | 0;
hi = hi + Math.imul(ah2, bh7) | 0;
lo = lo + Math.imul(al1, bl8) | 0;
mid = mid + Math.imul(al1, bh8) | 0;
mid = mid + Math.imul(ah1, bl8) | 0;
hi = hi + Math.imul(ah1, bh8) | 0;
lo = lo + Math.imul(al0, bl9) | 0;
mid = mid + Math.imul(al0, bh9) | 0;
mid = mid + Math.imul(ah0, bl9) | 0;
hi = hi + Math.imul(ah0, bh9) | 0;
var w9 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
w9 &= 67108863;
lo = Math.imul(al9, bl1);
mid = Math.imul(al9, bh1);
mid = mid + Math.imul(ah9, bl1) | 0;
hi = Math.imul(ah9, bh1);
lo = lo + Math.imul(al8, bl2) | 0;
mid = mid + Math.imul(al8, bh2) | 0;
mid = mid + Math.imul(ah8, bl2) | 0;
hi = hi + Math.imul(ah8, bh2) | 0;
lo = lo + Math.imul(al7, bl3) | 0;
mid = mid + Math.imul(al7, bh3) | 0;
mid = mid + Math.imul(ah7, bl3) | 0;
hi = hi + Math.imul(ah7, bh3) | 0;
lo = lo + Math.imul(al6, bl4) | 0;
mid = mid + Math.imul(al6, bh4) | 0;
mid = mid + Math.imul(ah6, bl4) | 0;
hi = hi + Math.imul(ah6, bh4) | 0;
lo = lo + Math.imul(al5, bl5) | 0;
mid = mid + Math.imul(al5, bh5) | 0;
mid = mid + Math.imul(ah5, bl5) | 0;
hi = hi + Math.imul(ah5, bh5) | 0;
lo = lo + Math.imul(al4, bl6) | 0;
mid = mid + Math.imul(al4, bh6) | 0;
mid = mid + Math.imul(ah4, bl6) | 0;
hi = hi + Math.imul(ah4, bh6) | 0;
lo = lo + Math.imul(al3, bl7) | 0;
mid = mid + Math.imul(al3, bh7) | 0;
mid = mid + Math.imul(ah3, bl7) | 0;
hi = hi + Math.imul(ah3, bh7) | 0;
lo = lo + Math.imul(al2, bl8) | 0;
mid = mid + Math.imul(al2, bh8) | 0;
mid = mid + Math.imul(ah2, bl8) | 0;
hi = hi + Math.imul(ah2, bh8) | 0;
lo = lo + Math.imul(al1, bl9) | 0;
mid = mid + Math.imul(al1, bh9) | 0;
mid = mid + Math.imul(ah1, bl9) | 0;
hi = hi + Math.imul(ah1, bh9) | 0;
var w10 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
w10 &= 67108863;
lo = Math.imul(al9, bl2);
mid = Math.imul(al9, bh2);
mid = mid + Math.imul(ah9, bl2) | 0;
hi = Math.imul(ah9, bh2);
lo = lo + Math.imul(al8, bl3) | 0;
mid = mid + Math.imul(al8, bh3) | 0;
mid = mid + Math.imul(ah8, bl3) | 0;
hi = hi + Math.imul(ah8, bh3) | 0;
lo = lo + Math.imul(al7, bl4) | 0;
mid = mid + Math.imul(al7, bh4) | 0;
mid = mid + Math.imul(ah7, bl4) | 0;
hi = hi + Math.imul(ah7, bh4) | 0;
lo = lo + Math.imul(al6, bl5) | 0;
mid = mid + Math.imul(al6, bh5) | 0;
mid = mid + Math.imul(ah6, bl5) | 0;
hi = hi + Math.imul(ah6, bh5) | 0;
lo = lo + Math.imul(al5, bl6) | 0;
mid = mid + Math.imul(al5, bh6) | 0;
mid = mid + Math.imul(ah5, bl6) | 0;
hi = hi + Math.imul(ah5, bh6) | 0;
lo = lo + Math.imul(al4, bl7) | 0;
mid = mid + Math.imul(al4, bh7) | 0;
mid = mid + Math.imul(ah4, bl7) | 0;
hi = hi + Math.imul(ah4, bh7) | 0;
lo = lo + Math.imul(al3, bl8) | 0;
mid = mid + Math.imul(al3, bh8) | 0;
mid = mid + Math.imul(ah3, bl8) | 0;
hi = hi + Math.imul(ah3, bh8) | 0;
lo = lo + Math.imul(al2, bl9) | 0;
mid = mid + Math.imul(al2, bh9) | 0;
mid = mid + Math.imul(ah2, bl9) | 0;
hi = hi + Math.imul(ah2, bh9) | 0;
var w11 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
w11 &= 67108863;
lo = Math.imul(al9, bl3);
mid = Math.imul(al9, bh3);
mid = mid + Math.imul(ah9, bl3) | 0;
hi = Math.imul(ah9, bh3);
lo = lo + Math.imul(al8, bl4) | 0;
mid = mid + Math.imul(al8, bh4) | 0;
mid = mid + Math.imul(ah8, bl4) | 0;
hi = hi + Math.imul(ah8, bh4) | 0;
lo = lo + Math.imul(al7, bl5) | 0;
mid = mid + Math.imul(al7, bh5) | 0;
mid = mid + Math.imul(ah7, bl5) | 0;
hi = hi + Math.imul(ah7, bh5) | 0;
lo = lo + Math.imul(al6, bl6) | 0;
mid = mid + Math.imul(al6, bh6) | 0;
mid = mid + Math.imul(ah6, bl6) | 0;
hi = hi + Math.imul(ah6, bh6) | 0;
lo = lo + Math.imul(al5, bl7) | 0;
mid = mid + Math.imul(al5, bh7) | 0;
mid = mid + Math.imul(ah5, bl7) | 0;
hi = hi + Math.imul(ah5, bh7) | 0;
lo = lo + Math.imul(al4, bl8) | 0;
mid = mid + Math.imul(al4, bh8) | 0;
mid = mid + Math.imul(ah4, bl8) | 0;
hi = hi + Math.imul(ah4, bh8) | 0;
lo = lo + Math.imul(al3, bl9) | 0;
mid = mid + Math.imul(al3, bh9) | 0;
mid = mid + Math.imul(ah3, bl9) | 0;
hi = hi + Math.imul(ah3, bh9) | 0;
var w12 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
w12 &= 67108863;
lo = Math.imul(al9, bl4);
mid = Math.imul(al9, bh4);
mid = mid + Math.imul(ah9, bl4) | 0;
hi = Math.imul(ah9, bh4);
lo = lo + Math.imul(al8, bl5) | 0;
mid = mid + Math.imul(al8, bh5) | 0;
mid = mid + Math.imul(ah8, bl5) | 0;
hi = hi + Math.imul(ah8, bh5) | 0;
lo = lo + Math.imul(al7, bl6) | 0;
mid = mid + Math.imul(al7, bh6) | 0;
mid = mid + Math.imul(ah7, bl6) | 0;
hi = hi + Math.imul(ah7, bh6) | 0;
lo = lo + Math.imul(al6, bl7) | 0;
mid = mid + Math.imul(al6, bh7) | 0;
mid = mid + Math.imul(ah6, bl7) | 0;
hi = hi + Math.imul(ah6, bh7) | 0;
lo = lo + Math.imul(al5, bl8) | 0;
mid = mid + Math.imul(al5, bh8) | 0;
mid = mid + Math.imul(ah5, bl8) | 0;
hi = hi + Math.imul(ah5, bh8) | 0;
lo = lo + Math.imul(al4, bl9) | 0;
mid = mid + Math.imul(al4, bh9) | 0;
mid = mid + Math.imul(ah4, bl9) | 0;
hi = hi + Math.imul(ah4, bh9) | 0;
var w13 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
w13 &= 67108863;
lo = Math.imul(al9, bl5);
mid = Math.imul(al9, bh5);
mid = mid + Math.imul(ah9, bl5) | 0;
hi = Math.imul(ah9, bh5);
lo = lo + Math.imul(al8, bl6) | 0;
mid = mid + Math.imul(al8, bh6) | 0;
mid = mid + Math.imul(ah8, bl6) | 0;
hi = hi + Math.imul(ah8, bh6) | 0;
lo = lo + Math.imul(al7, bl7) | 0;
mid = mid + Math.imul(al7, bh7) | 0;
mid = mid + Math.imul(ah7, bl7) | 0;
hi = hi + Math.imul(ah7, bh7) | 0;
lo = lo + Math.imul(al6, bl8) | 0;
mid = mid + Math.imul(al6, bh8) | 0;
mid = mid + Math.imul(ah6, bl8) | 0;
hi = hi + Math.imul(ah6, bh8) | 0;
lo = lo + Math.imul(al5, bl9) | 0;
mid = mid + Math.imul(al5, bh9) | 0;
mid = mid + Math.imul(ah5, bl9) | 0;
hi = hi + Math.imul(ah5, bh9) | 0;
var w14 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
w14 &= 67108863;
lo = Math.imul(al9, bl6);
mid = Math.imul(al9, bh6);
mid = mid + Math.imul(ah9, bl6) | 0;
hi = Math.imul(ah9, bh6);
lo = lo + Math.imul(al8, bl7) | 0;
mid = mid + Math.imul(al8, bh7) | 0;
mid = mid + Math.imul(ah8, bl7) | 0;
hi = hi + Math.imul(ah8, bh7) | 0;
lo = lo + Math.imul(al7, bl8) | 0;
mid = mid + Math.imul(al7, bh8) | 0;
mid = mid + Math.imul(ah7, bl8) | 0;
hi = hi + Math.imul(ah7, bh8) | 0;
lo = lo + Math.imul(al6, bl9) | 0;
mid = mid + Math.imul(al6, bh9) | 0;
mid = mid + Math.imul(ah6, bl9) | 0;
hi = hi + Math.imul(ah6, bh9) | 0;
var w15 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
w15 &= 67108863;
lo = Math.imul(al9, bl7);
mid = Math.imul(al9, bh7);
mid = mid + Math.imul(ah9, bl7) | 0;
hi = Math.imul(ah9, bh7);
lo = lo + Math.imul(al8, bl8) | 0;
mid = mid + Math.imul(al8, bh8) | 0;
mid = mid + Math.imul(ah8, bl8) | 0;
hi = hi + Math.imul(ah8, bh8) | 0;
lo = lo + Math.imul(al7, bl9) | 0;
mid = mid + Math.imul(al7, bh9) | 0;
mid = mid + Math.imul(ah7, bl9) | 0;
hi = hi + Math.imul(ah7, bh9) | 0;
var w16 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
w16 &= 67108863;
lo = Math.imul(al9, bl8);
mid = Math.imul(al9, bh8);
mid = mid + Math.imul(ah9, bl8) | 0;
hi = Math.imul(ah9, bh8);
lo = lo + Math.imul(al8, bl9) | 0;
mid = mid + Math.imul(al8, bh9) | 0;
mid = mid + Math.imul(ah8, bl9) | 0;
hi = hi + Math.imul(ah8, bh9) | 0;
var w17 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
w17 &= 67108863;
lo = Math.imul(al9, bl9);
mid = Math.imul(al9, bh9);
mid = mid + Math.imul(ah9, bl9) | 0;
hi = Math.imul(ah9, bh9);
var w18 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
c2 = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
w18 &= 67108863;
o2[0] = w0;
o2[1] = w1;
o2[2] = w2;
o2[3] = w3;
o2[4] = w4;
o2[5] = w5;
o2[6] = w6;
o2[7] = w7;
o2[8] = w8;
o2[9] = w9;
o2[10] = w10;
o2[11] = w11;
o2[12] = w12;
o2[13] = w13;
o2[14] = w14;
o2[15] = w15;
o2[16] = w16;
o2[17] = w17;
o2[18] = w18;
if (c2 !== 0) {
o2[19] = c2;
out.length++;
}
return out;
};
if (!Math.imul) {
comb10MulTo = smallMulTo;
}
function bigMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.length + num.length;
var carry = 0;
var hncarry = 0;
for (var k2 = 0; k2 < out.length - 1; k2++) {
var ncarry = hncarry;
hncarry = 0;
var rword = carry & 67108863;
var maxJ = Math.min(k2, num.length - 1);
for (var j2 = Math.max(0, k2 - self.length + 1); j2 <= maxJ; j2++) {
var i2 = k2 - j2;
var a2 = self.words[i2] | 0;
var b2 = num.words[j2] | 0;
var r2 = a2 * b2;
var lo = r2 & 67108863;
ncarry = ncarry + (r2 / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k2] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) {
out.words[k2] = carry;
} else {
out.length--;
}
return out.strip();
}
function jumboMulTo(self, num, out) {
var fftm = new FFTM();
return fftm.mulp(self, num, out);
}
BN2.prototype.mulTo = function mulTo(num, out) {
var res;
var len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = comb10MulTo(this, num, out);
} else if (len < 63) {
res = smallMulTo(this, num, out);
} else if (len < 1024) {
res = bigMulTo(this, num, out);
} else {
res = jumboMulTo(this, num, out);
}
return res;
};
function FFTM(x2, y2) {
this.x = x2;
this.y = y2;
}
FFTM.prototype.makeRBT = function makeRBT(N2) {
var t2 = new Array(N2);
var l2 = BN2.prototype._countBits(N2) - 1;
for (var i2 = 0; i2 < N2; i2++) {
t2[i2] = this.revBin(i2, l2, N2);
}
return t2;
};
FFTM.prototype.revBin = function revBin(x2, l2, N2) {
if (x2 === 0 || x2 === N2 - 1)
return x2;
var rb = 0;
for (var i2 = 0; i2 < l2; i2++) {
rb |= (x2 & 1) << l2 - i2 - 1;
x2 >>= 1;
}
return rb;
};
FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N2) {
for (var i2 = 0; i2 < N2; i2++) {
rtws[i2] = rws[rbt[i2]];
itws[i2] = iws[rbt[i2]];
}
};
FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N2, rbt) {
this.permute(rbt, rws, iws, rtws, itws, N2);
for (var s2 = 1; s2 < N2; s2 <<= 1) {
var l2 = s2 << 1;
var rtwdf = Math.cos(2 * Math.PI / l2);
var itwdf = Math.sin(2 * Math.PI / l2);
for (var p2 = 0; p2 < N2; p2 += l2) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j2 = 0; j2 < s2; j2++) {
var re = rtws[p2 + j2];
var ie = itws[p2 + j2];
var ro = rtws[p2 + j2 + s2];
var io = itws[p2 + j2 + s2];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p2 + j2] = re + ro;
itws[p2 + j2] = ie + io;
rtws[p2 + j2 + s2] = re - ro;
itws[p2 + j2 + s2] = ie - io;
if (j2 !== l2) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n2, m2) {
var N2 = Math.max(m2, n2) | 1;
var odd = N2 & 1;
var i2 = 0;
for (N2 = N2 / 2 | 0; N2; N2 = N2 >>> 1) {
i2++;
}
return 1 << i2 + 1 + odd;
};
FFTM.prototype.conjugate = function conjugate(rws, iws, N2) {
if (N2 <= 1)
return;
for (var i2 = 0; i2 < N2 / 2; i2++) {
var t2 = rws[i2];
rws[i2] = rws[N2 - i2 - 1];
rws[N2 - i2 - 1] = t2;
t2 = iws[i2];
iws[i2] = -iws[N2 - i2 - 1];
iws[N2 - i2 - 1] = -t2;
}
};
FFTM.prototype.normalize13b = function normalize13b(ws, N2) {
var carry = 0;
for (var i2 = 0; i2 < N2 / 2; i2++) {
var w2 = Math.round(ws[2 * i2 + 1] / N2) * 8192 + Math.round(ws[2 * i2] / N2) + carry;
ws[i2] = w2 & 67108863;
if (w2 < 67108864) {
carry = 0;
} else {
carry = w2 / 67108864 | 0;
}
}
return ws;
};
FFTM.prototype.convert13b = function convert13b(ws, len, rws, N2) {
var carry = 0;
for (var i2 = 0; i2 < len; i2++) {
carry = carry + (ws[i2] | 0);
rws[2 * i2] = carry & 8191;
carry = carry >>> 13;
rws[2 * i2 + 1] = carry & 8191;
carry = carry >>> 13;
}
for (i2 = 2 * len; i2 < N2; ++i2) {
rws[i2] = 0;
}
assert(carry === 0);
assert((carry & ~8191) === 0);
};
FFTM.prototype.stub = function stub(N2) {
var ph = new Array(N2);
for (var i2 = 0; i2 < N2; i2++) {
ph[i2] = 0;
}
return ph;
};
FFTM.prototype.mulp = function mulp(x2, y2, out) {
var N2 = 2 * this.guessLen13b(x2.length, y2.length);
var rbt = this.makeRBT(N2);
var _2 = this.stub(N2);
var rws = new Array(N2);
var rwst = new Array(N2);
var iwst = new Array(N2);
var nrws = new Array(N2);
var nrwst = new Array(N2);
var niwst = new Array(N2);
var rmws = out.words;
rmws.length = N2;
this.convert13b(x2.words, x2.length, rws, N2);
this.convert13b(y2.words, y2.length, nrws, N2);
this.transform(rws, _2, rwst, iwst, N2, rbt);
this.transform(nrws, _2, nrwst, niwst, N2, rbt);
for (var i2 = 0; i2 < N2; i2++) {
var rx = rwst[i2] * nrwst[i2] - iwst[i2] * niwst[i2];
iwst[i2] = rwst[i2] * niwst[i2] + iwst[i2] * nrwst[i2];
rwst[i2] = rx;
}
this.conjugate(rwst, iwst, N2);
this.transform(rwst, iwst, rmws, _2, N2, rbt);
this.conjugate(rmws, _2, N2);
this.normalize13b(rmws, N2);
out.negative = x2.negative ^ y2.negative;
out.length = x2.length + y2.length;
return out.strip();
};
BN2.prototype.mul = function mul2(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN2.prototype.mulf = function mulf(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN2.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN2.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var i2 = 0; i2 < this.length; i2++) {
var w2 = (this.words[i2] | 0) * num;
var lo = (w2 & 67108863) + (carry & 67108863);
carry >>= 26;
carry += w2 / 67108864 | 0;
carry += lo >>> 26;
this.words[i2] = lo & 67108863;
}
if (carry !== 0) {
this.words[i2] = carry;
this.length++;
}
return this;
};
BN2.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN2.prototype.sqr = function sqr() {
return this.mul(this);
};
BN2.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN2.prototype.pow = function pow(num) {
var w2 = toBitArray(num);
if (w2.length === 0)
return new BN2(1);
var res = this;
for (var i2 = 0; i2 < w2.length; i2++, res = res.sqr()) {
if (w2[i2] !== 0)
break;
}
if (++i2 < w2.length) {
for (var q2 = res.sqr(); i2 < w2.length; i2++, q2 = q2.sqr()) {
if (w2[i2] === 0)
continue;
res = res.mul(q2);
}
}
return res;
};
BN2.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
var carryMask = 67108863 >>> 26 - r2 << 26 - r2;
var i2;
if (r2 !== 0) {
var carry = 0;
for (i2 = 0; i2 < this.length; i2++) {
var newCarry = this.words[i2] & carryMask;
var c2 = (this.words[i2] | 0) - newCarry << r2;
this.words[i2] = c2 | carry;
carry = newCarry >>> 26 - r2;
}
if (carry) {
this.words[i2] = carry;
this.length++;
}
}
if (s2 !== 0) {
for (i2 = this.length - 1; i2 >= 0; i2--) {
this.words[i2 + s2] = this.words[i2];
}
for (i2 = 0; i2 < s2; i2++) {
this.words[i2] = 0;
}
this.length += s2;
}
return this.strip();
};
BN2.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN2.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h2;
if (hint) {
h2 = (hint - hint % 26) / 26;
} else {
h2 = 0;
}
var r2 = bits % 26;
var s2 = Math.min((bits - r2) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r2 << r2;
var maskedWords = extended;
h2 -= s2;
h2 = Math.max(0, h2);
if (maskedWords) {
for (var i2 = 0; i2 < s2; i2++) {
maskedWords.words[i2] = this.words[i2];
}
maskedWords.length = s2;
}
if (s2 === 0)
;
else if (this.length > s2) {
this.length -= s2;
for (i2 = 0; i2 < this.length; i2++) {
this.words[i2] = this.words[i2 + s2];
}
} else {
this.words[0] = 0;
this.length = 1;
}
var carry = 0;
for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h2); i2--) {
var word = this.words[i2] | 0;
this.words[i2] = carry << 26 - r2 | word >>> r2;
carry = word & mask;
}
if (maskedWords && carry !== 0) {
maskedWords.words[maskedWords.length++] = carry;
}
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN2.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN2.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN2.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN2.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN2.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN2.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q2 = 1 << r2;
if (this.length <= s2)
return false;
var w2 = this.words[s2];
return !!(w2 & q2);
};
BN2.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s2) {
return this;
}
if (r2 !== 0) {
s2++;
}
this.length = Math.min(s2, this.length);
if (r2 !== 0) {
var mask = 67108863 ^ 67108863 >>> r2 << r2;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN2.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN2.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0)
return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN2.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) {
this.words[i2] -= 67108864;
if (i2 === this.length - 1) {
this.words[i2 + 1] = 1;
} else {
this.words[i2 + 1]++;
}
}
this.length = Math.max(this.length, i2 + 1);
return this;
};
BN2.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0)
return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else {
for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) {
this.words[i2] += 67108864;
this.words[i2 + 1] -= 1;
}
}
return this.strip();
};
BN2.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN2.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN2.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN2.prototype.abs = function abs() {
return this.clone().iabs();
};
BN2.prototype._ishlnsubmul = function _ishlnsubmul(num, mul2, shift) {
var len = num.length + shift;
var i2;
this._expand(len);
var w2;
var carry = 0;
for (i2 = 0; i2 < num.length; i2++) {
w2 = (this.words[i2 + shift] | 0) + carry;
var right = (num.words[i2] | 0) * mul2;
w2 -= right & 67108863;
carry = (w2 >> 26) - (right / 67108864 | 0);
this.words[i2 + shift] = w2 & 67108863;
}
for (; i2 < this.length - shift; i2++) {
w2 = (this.words[i2 + shift] | 0) + carry;
carry = w2 >> 26;
this.words[i2 + shift] = w2 & 67108863;
}
if (carry === 0)
return this.strip();
assert(carry === -1);
carry = 0;
for (i2 = 0; i2 < this.length; i2++) {
w2 = -(this.words[i2] | 0) + carry;
carry = w2 >> 26;
this.words[i2] = w2 & 67108863;
}
this.negative = 1;
return this.strip();
};
BN2.prototype._wordDiv = function _wordDiv(num, mode2) {
var shift = this.length - num.length;
var a2 = this.clone();
var b2 = num;
var bhi = b2.words[b2.length - 1] | 0;
var bhiBits = this._countBits(bhi);
shift = 26 - bhiBits;
if (shift !== 0) {
b2 = b2.ushln(shift);
a2.iushln(shift);
bhi = b2.words[b2.length - 1] | 0;
}
var m2 = a2.length - b2.length;
var q2;
if (mode2 !== "mod") {
q2 = new BN2(null);
q2.length = m2 + 1;
q2.words = new Array(q2.length);
for (var i2 = 0; i2 < q2.length; i2++) {
q2.words[i2] = 0;
}
}
var diff = a2.clone()._ishlnsubmul(b2, 1, m2);
if (diff.negative === 0) {
a2 = diff;
if (q2) {
q2.words[m2] = 1;
}
}
for (var j2 = m2 - 1; j2 >= 0; j2--) {
var qj = (a2.words[b2.length + j2] | 0) * 67108864 + (a2.words[b2.length + j2 - 1] | 0);
qj = Math.min(qj / bhi | 0, 67108863);
a2._ishlnsubmul(b2, qj, j2);
while (a2.negative !== 0) {
qj--;
a2.negative = 0;
a2._ishlnsubmul(b2, 1, j2);
if (!a2.isZero()) {
a2.negative ^= 1;
}
}
if (q2) {
q2.words[j2] = qj;
}
}
if (q2) {
q2.strip();
}
a2.strip();
if (mode2 !== "div" && shift !== 0) {
a2.iushrn(shift);
}
return {
div: q2 || null,
mod: a2
};
};
BN2.prototype.divmod = function divmod(num, mode2, positive) {
assert(!num.isZero());
if (this.isZero()) {
return {
div: new BN2(0),
mod: new BN2(0)
};
}
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode2);
if (mode2 !== "mod") {
div = res.div.neg();
}
if (mode2 !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) {
mod.iadd(num);
}
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode2);
if (mode2 !== "mod") {
div = res.div.neg();
}
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode2);
if (mode2 !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) {
mod.isub(num);
}
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) {
return {
div: new BN2(0),
mod: this
};
}
if (num.length === 1) {
if (mode2 === "div") {
return {
div: this.divn(num.words[0]),
mod: null
};
}
if (mode2 === "mod") {
return {
div: null,
mod: new BN2(this.modn(num.words[0]))
};
}
return {
div: this.divn(num.words[0]),
mod: new BN2(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode2);
};
BN2.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN2.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN2.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN2.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero())
return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0)
return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN2.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p2 = (1 << 26) % num;
var acc = 0;
for (var i2 = this.length - 1; i2 >= 0; i2--) {
acc = (p2 * acc + (this.words[i2] | 0)) % num;
}
return acc;
};
BN2.prototype.idivn = function idivn(num) {
assert(num <= 67108863);
var carry = 0;
for (var i2 = this.length - 1; i2 >= 0; i2--) {
var w2 = (this.words[i2] | 0) + carry * 67108864;
this.words[i2] = w2 / num | 0;
carry = w2 % num;
}
return this.strip();
};
BN2.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN2.prototype.egcd = function egcd(p2) {
assert(p2.negative === 0);
assert(!p2.isZero());
var x2 = this;
var y2 = p2.clone();
if (x2.negative !== 0) {
x2 = x2.umod(p2);
} else {
x2 = x2.clone();
}
var A2 = new BN2(1);
var B2 = new BN2(0);
var C2 = new BN2(0);
var D2 = new BN2(1);
var g2 = 0;
while (x2.isEven() && y2.isEven()) {
x2.iushrn(1);
y2.iushrn(1);
++g2;
}
var yp = y2.clone();
var xp = x2.clone();
while (!x2.isZero()) {
for (var i2 = 0, im = 1; (x2.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1)
;
if (i2 > 0) {
x2.iushrn(i2);
while (i2-- > 0) {
if (A2.isOdd() || B2.isOdd()) {
A2.iadd(yp);
B2.isub(xp);
}
A2.iushrn(1);
B2.iushrn(1);
}
}
for (var j2 = 0, jm = 1; (y2.words[0] & jm) === 0 && j2 < 26; ++j2, jm <<= 1)
;
if (j2 > 0) {
y2.iushrn(j2);
while (j2-- > 0) {
if (C2.isOdd() || D2.isOdd()) {
C2.iadd(yp);
D2.isub(xp);
}
C2.iushrn(1);
D2.iushrn(1);
}
}
if (x2.cmp(y2) >= 0) {
x2.isub(y2);
A2.isub(C2);
B2.isub(D2);
} else {
y2.isub(x2);
C2.isub(A2);
D2.isub(B2);
}
}
return {
a: C2,
b: D2,
gcd: y2.iushln(g2)
};
};
BN2.prototype._invmp = function _invmp(p2) {
assert(p2.negative === 0);
assert(!p2.isZero());
var a2 = this;
var b2 = p2.clone();
if (a2.negative !== 0) {
a2 = a2.umod(p2);
} else {
a2 = a2.clone();
}
var x1 = new BN2(1);
var x2 = new BN2(0);
var delta = b2.clone();
while (a2.cmpn(1) > 0 && b2.cmpn(1) > 0) {
for (var i2 = 0, im = 1; (a2.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1)
;
if (i2 > 0) {
a2.iushrn(i2);
while (i2-- > 0) {
if (x1.isOdd()) {
x1.iadd(delta);
}
x1.iushrn(1);
}
}
for (var j2 = 0, jm = 1; (b2.words[0] & jm) === 0 && j2 < 26; ++j2, jm <<= 1)
;
if (j2 > 0) {
b2.iushrn(j2);
while (j2-- > 0) {
if (x2.isOdd()) {
x2.iadd(delta);
}
x2.iushrn(1);
}
}
if (a2.cmp(b2) >= 0) {
a2.isub(b2);
x1.isub(x2);
} else {
b2.isub(a2);
x2.isub(x1);
}
}
var res;
if (a2.cmpn(1) === 0) {
res = x1;
} else {
res = x2;
}
if (res.cmpn(0) < 0) {
res.iadd(p2);
}
return res;
};
BN2.prototype.gcd = function gcd(num) {
if (this.isZero())
return num.abs();
if (num.isZero())
return this.abs();
var a2 = this.clone();
var b2 = num.clone();
a2.negative = 0;
b2.negative = 0;
for (var shift = 0; a2.isEven() && b2.isEven(); shift++) {
a2.iushrn(1);
b2.iushrn(1);
}
do {
while (a2.isEven()) {
a2.iushrn(1);
}
while (b2.isEven()) {
b2.iushrn(1);
}
var r2 = a2.cmp(b2);
if (r2 < 0) {
var t2 = a2;
a2 = b2;
b2 = t2;
} else if (r2 === 0 || b2.cmpn(1) === 0) {
break;
}
a2.isub(b2);
} while (true);
return b2.iushln(shift);
};
BN2.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN2.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN2.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN2.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN2.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q2 = 1 << r2;
if (this.length <= s2) {
this._expand(s2 + 1);
this.words[s2] |= q2;
return this;
}
var carry = q2;
for (var i2 = s2; carry !== 0 && i2 < this.length; i2++) {
var w2 = this.words[i2] | 0;
w2 += carry;
carry = w2 >>> 26;
w2 &= 67108863;
this.words[i2] = w2;
}
if (carry !== 0) {
this.words[i2] = carry;
this.length++;
}
return this;
};
BN2.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN2.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative)
return -1;
if (this.negative === 0 && negative)
return 1;
this.strip();
var res;
if (this.length > 1) {
res = 1;
} else {
if (negative) {
num = -num;
}
assert(num <= 67108863, "Number is too big");
var w2 = this.words[0] | 0;
res = w2 === num ? 0 : w2 < num ? -1 : 1;
}
if (this.negative !== 0)
return -res | 0;
return res;
};
BN2.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0)
return -1;
if (this.negative === 0 && num.negative !== 0)
return 1;
var res = this.ucmp(num);
if (this.negative !== 0)
return -res | 0;
return res;
};
BN2.prototype.ucmp = function ucmp(num) {
if (this.length > num.length)
return 1;
if (this.length < num.length)
return -1;
var res = 0;
for (var i2 = this.length - 1; i2 >= 0; i2--) {
var a2 = this.words[i2] | 0;
var b2 = num.words[i2] | 0;
if (a2 === b2)
continue;
if (a2 < b2) {
res = -1;
} else if (a2 > b2) {
res = 1;
}
break;
}
return res;
};
BN2.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN2.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN2.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN2.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN2.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN2.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN2.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN2.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN2.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN2.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN2.red = function red(num) {
return new Red(num);
};
BN2.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN2.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN2.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN2.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN2.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN2.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN2.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN2.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN2.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN2.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN2.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN2.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN2.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN2.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN2.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN2.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN2.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p2) {
this.name = name;
this.p = new BN2(p2, 16);
this.n = this.p.bitLength();
this.k = new BN2(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN2(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r2 = num;
var rlen;
do {
this.split(r2, this.tmp);
r2 = this.imulK(r2);
r2 = r2.iadd(this.tmp);
rlen = r2.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r2.ucmp(this.p);
if (cmp === 0) {
r2.words[0] = 0;
r2.length = 1;
} else if (cmp > 0) {
r2.isub(this.p);
} else {
r2.strip();
}
return r2;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(
this,
"k256",
"ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
);
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var i2 = 0; i2 < outLen; i2++) {
output.words[i2] = input.words[i2];
}
output.length = outLen;
if (input.length <= 9) {
input.words[0] = 0;
input.length = 1;
return;
}
var prev = input.words[9];
output.words[output.length++] = prev & mask;
for (i2 = 10; i2 < input.length; i2++) {
var next = input.words[i2] | 0;
input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22;
prev = next;
}
prev >>>= 22;
input.words[i2 - 10] = prev;
if (prev === 0 && input.length > 10) {
input.length -= 10;
} else {
input.length -= 9;
}
};
K256.prototype.imulK = function imulK(num) {
num.words[num.length] = 0;
num.words[num.length + 1] = 0;
num.length += 2;
var lo = 0;
for (var i2 = 0; i2 < num.length; i2++) {
var w2 = num.words[i2] | 0;
lo += w2 * 977;
num.words[i2] = lo & 67108863;
lo = w2 * 64 + (lo / 67108864 | 0);
}
if (num.words[num.length - 1] === 0) {
num.length--;
if (num.words[num.length - 1] === 0) {
num.length--;
}
}
return num;
};
function P224() {
MPrime.call(
this,
"p224",
"ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
);
}
inherits(P224, MPrime);
function P192() {
MPrime.call(
this,
"p192",
"ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
);
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(
this,
"25519",
"7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
);
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var i2 = 0; i2 < num.length; i2++) {
var hi = (num.words[i2] | 0) * 19 + carry;
var lo = hi & 67108863;
hi >>>= 26;
num.words[i2] = lo;
carry = hi;
}
if (carry !== 0) {
num.words[num.length++] = carry;
}
return num;
};
BN2._prime = function prime(name) {
if (primes[name])
return primes[name];
var prime2;
if (name === "k256") {
prime2 = new K256();
} else if (name === "p224") {
prime2 = new P224();
} else if (name === "p192") {
prime2 = new P192();
} else if (name === "p25519") {
prime2 = new P25519();
} else {
throw new Error("Unknown prime " + name);
}
primes[name] = prime2;
return prime2;
};
function Red(m2) {
if (typeof m2 === "string") {
var prime = BN2._prime(m2);
this.m = prime.p;
this.prime = prime;
} else {
assert(m2.gtn(1), "modulus must be greater than 1");
this.m = m2;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a2) {
assert(a2.negative === 0, "red works only with positives");
assert(a2.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a2, b2) {
assert((a2.negative | b2.negative) === 0, "red works only with positives");
assert(
a2.red && a2.red === b2.red,
"red works only with red numbers"
);
};
Red.prototype.imod = function imod(a2) {
if (this.prime)
return this.prime.ireduce(a2)._forceRed(this);
return a2.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a2) {
if (a2.isZero()) {
return a2.clone();
}
return this.m.sub(a2)._forceRed(this);
};
Red.prototype.add = function add(a2, b2) {
this._verify2(a2, b2);
var res = a2.add(b2);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a2, b2) {
this._verify2(a2, b2);
var res = a2.iadd(b2);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res;
};
Red.prototype.sub = function sub(a2, b2) {
this._verify2(a2, b2);
var res = a2.sub(b2);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res._forceRed(this);
};
Red.prototype.isub = function isub(a2, b2) {
this._verify2(a2, b2);
var res = a2.isub(b2);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res;
};
Red.prototype.shl = function shl(a2, num) {
this._verify1(a2);
return this.imod(a2.ushln(num));
};
Red.prototype.imul = function imul(a2, b2) {
this._verify2(a2, b2);
return this.imod(a2.imul(b2));
};
Red.prototype.mul = function mul2(a2, b2) {
this._verify2(a2, b2);
return this.imod(a2.mul(b2));
};
Red.prototype.isqr = function isqr(a2) {
return this.imul(a2, a2.clone());
};
Red.prototype.sqr = function sqr(a2) {
return this.mul(a2, a2);
};
Red.prototype.sqrt = function sqrt(a2) {
if (a2.isZero())
return a2.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN2(1)).iushrn(2);
return this.pow(a2, pow);
}
var q2 = this.m.subn(1);
var s2 = 0;
while (!q2.isZero() && q2.andln(1) === 0) {
s2++;
q2.iushrn(1);
}
assert(!q2.isZero());
var one = new BN2(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z2 = this.m.bitLength();
z2 = new BN2(2 * z2 * z2).toRed(this);
while (this.pow(z2, lpow).cmp(nOne) !== 0) {
z2.redIAdd(nOne);
}
var c2 = this.pow(z2, q2);
var r2 = this.pow(a2, q2.addn(1).iushrn(1));
var t2 = this.pow(a2, q2);
var m2 = s2;
while (t2.cmp(one) !== 0) {
var tmp = t2;
for (var i2 = 0; tmp.cmp(one) !== 0; i2++) {
tmp = tmp.redSqr();
}
assert(i2 < m2);
var b2 = this.pow(c2, new BN2(1).iushln(m2 - i2 - 1));
r2 = r2.redMul(b2);
c2 = b2.redSqr();
t2 = t2.redMul(c2);
m2 = i2;
}
return r2;
};
Red.prototype.invm = function invm(a2) {
var inv = a2._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else {
return this.imod(inv);
}
};
Red.prototype.pow = function pow(a2, num) {
if (num.isZero())
return new BN2(1).toRed(this);
if (num.cmpn(1) === 0)
return a2.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN2(1).toRed(this);
wnd[1] = a2;
for (var i2 = 2; i2 < wnd.length; i2++) {
wnd[i2] = this.mul(wnd[i2 - 1], a2);
}
var res = wnd[0];
var current = 0;
var currentLen = 0;
var start = num.bitLength() % 26;
if (start === 0) {
start = 26;
}
for (i2 = num.length - 1; i2 >= 0; i2--) {
var word = num.words[i2];
for (var j2 = start - 1; j2 >= 0; j2--) {
var bit = word >> j2 & 1;
if (res !== wnd[0]) {
res = this.sqr(res);
}
if (bit === 0 && current === 0) {
currentLen = 0;
continue;
}
current <<= 1;
current |= bit;
currentLen++;
if (currentLen !== windowSize && (i2 !== 0 || j2 !== 0))
continue;
res = this.mul(res, wnd[current]);
currentLen = 0;
current = 0;
}
start = 26;
}
return res;
};
Red.prototype.convertTo = function convertTo(num) {
var r2 = num.umod(this.m);
return r2 === num ? r2.clone() : r2;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN2.mont = function mont(num) {
return new Mont(num);
};
function Mont(m2) {
Red.call(this, m2);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) {
this.shift += 26 - this.shift % 26;
}
this.r = new BN2(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r2 = this.imod(num.mul(this.rinv));
r2.red = null;
return r2;
};
Mont.prototype.imul = function imul(a2, b2) {
if (a2.isZero() || b2.isZero()) {
a2.words[0] = 0;
a2.length = 1;
return a2;
}
var t2 = a2.imul(b2);
var c2 = t2.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u2 = t2.isub(c2).iushrn(this.shift);
var res = u2;
if (u2.cmp(this.m) >= 0) {
res = u2.isub(this.m);
} else if (u2.cmpn(0) < 0) {
res = u2.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.mul = function mul2(a2, b2) {
if (a2.isZero() || b2.isZero())
return new BN2(0)._forceRed(this);
var t2 = a2.mul(b2);
var c2 = t2.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u2 = t2.isub(c2).iushrn(this.shift);
var res = u2;
if (u2.cmp(this.m) >= 0) {
res = u2.isub(this.m);
} else if (u2.cmpn(0) < 0) {
res = u2.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a2) {
var res = this.imod(a2._invmp(this.m).mul(this.r2));
return res._forceRed(this);
};
})(module, commonjsGlobal);
})(bn);
const BN = bnExports;
var isTypedarray = isTypedArray$1;
isTypedArray$1.strict = isStrictTypedArray;
isTypedArray$1.loose = isLooseTypedArray;
var toString$1 = Object.prototype.toString;
var names = {
"[object Int8Array]": true,
"[object Int16Array]": true,
"[object Int32Array]": true,
"[object Uint8Array]": true,
"[object Uint8ClampedArray]": true,
"[object Uint16Array]": true,
"[object Uint32Array]": true,
"[object Float32Array]": true,
"[object Float64Array]": true
};
function isTypedArray$1(arr) {
return isStrictTypedArray(arr) || isLooseTypedArray(arr);
}
function isStrictTypedArray(arr) {
return arr instanceof Int8Array || arr instanceof Int16Array || arr instanceof Int32Array || arr instanceof Uint8Array || arr instanceof Uint8ClampedArray || arr instanceof Uint16Array || arr instanceof Uint32Array || arr instanceof Float32Array || arr instanceof Float64Array;
}
function isLooseTypedArray(arr) {
return names[toString$1.call(arr)];
}
var isTypedArray = isTypedarray.strict;
var typedarrayToBuffer = function typedarrayToBuffer2(arr) {
if (isTypedArray(arr)) {
var buf = Buffer.from(arr.buffer);
if (arr.byteLength !== arr.buffer.byteLength) {
buf = buf.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
}
return buf;
} else {
return Buffer.from(arr);
}
};
const ENC_HEX = "hex";
const ENC_UTF8 = "utf8";
const STRING_ZERO = "0";
function bufferToArray(buf) {
return new Uint8Array(buf);
}
function bufferToHex(buf, prefixed = false) {
const hex = buf.toString(ENC_HEX);
return prefixed ? addHexPrefix(hex) : hex;
}
function bufferToUtf8(buf) {
return buf.toString(ENC_UTF8);
}
function arrayToBuffer(arr) {
return typedarrayToBuffer(arr);
}
function arrayToHex(arr, prefixed = false) {
return bufferToHex(arrayToBuffer(arr), prefixed);
}
function arrayToUtf8(arr) {
return bufferToUtf8(arrayToBuffer(arr));
}
function hexToBuffer(hex) {
return Buffer.from(removeHexPrefix(hex), ENC_HEX);
}
function hexToArray(hex) {
return bufferToArray(hexToBuffer(hex));
}
function utf8ToBuffer(utf8) {
return Buffer.from(utf8, ENC_UTF8);
}
function utf8ToArray(utf8) {
return bufferToArray(utf8ToBuffer(utf8));
}
function utf8ToHex(utf8, prefixed = false) {
return bufferToHex(utf8ToBuffer(utf8), prefixed);
}
function isHexString$1(str, length) {
if (typeof str !== "string" || !str.match(/^0x[0-9A-Fa-f]*$/)) {
return false;
}
if (length && str.length !== 2 + 2 * length) {
return false;
}
return true;
}
function concatArrays(...args) {
let result = [];
args.forEach((arg) => result = result.concat(Array.from(arg)));
return new Uint8Array([...result]);
}
function calcByteLength(length, byteSize = 8) {
const remainder = length % byteSize;
return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
}
function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
return padLeft(str, calcByteLength(str.length, byteSize), padding);
}
function padLeft(str, length, padding = STRING_ZERO) {
return padString(str, length, true, padding);
}
function removeHexPrefix(hex) {
return hex.replace(/^0x/, "");
}
function addHexPrefix(hex) {
return hex.startsWith("0x") ? hex : `0x${hex}`;
}
function sanitizeHex$1(hex) {
hex = removeHexPrefix(hex);
hex = sanitizeBytes(hex, 2);
if (hex) {
hex = addHexPrefix(hex);
}
return hex;
}
function removeHexLeadingZeros$1(hex) {
const prefixed = hex.startsWith("0x");
hex = removeHexPrefix(hex);
hex = hex.startsWith(STRING_ZERO) ? hex.substring(1) : hex;
return prefixed ? addHexPrefix(hex) : hex;
}
function padString(str, length, left, padding = STRING_ZERO) {
const diff = length - str.length;
let result = str;
if (diff > 0) {
const pad = padding.repeat(diff);
result = left ? pad + str : str + pad;
}
return result;
}
function convertArrayBufferToBuffer(arrBuf) {
return arrayToBuffer(new Uint8Array(arrBuf));
}
function convertArrayBufferToHex(arrBuf, noPrefix) {
return arrayToHex(new Uint8Array(arrBuf), !noPrefix);
}
function convertBufferToArrayBuffer(buf) {
return bufferToArray(buf).buffer;
}
function convertUtf8ToBuffer(utf8) {
return utf8ToBuffer(utf8);
}
function convertUtf8ToHex(utf8, noPrefix) {
return utf8ToHex(utf8, !noPrefix);
}
function convertHexToArrayBuffer(hex) {
return hexToArray(hex).buffer;
}
function convertNumberToHex(num, noPrefix) {
const hex = removeHexPrefix(sanitizeHex$1(new BN(num).toString(16)));
return noPrefix ? hex : addHexPrefix(hex);
}
function sanitizeHex(hex) {
return sanitizeHex$1(hex);
}
function removeHexLeadingZeros(hex) {
return removeHexLeadingZeros$1(addHexPrefix(hex));
}
const payloadId = payloadId$1;
function uuid() {
const result = ((a2, b2) => {
for (b2 = a2 = ""; a2++ < 36; b2 += a2 * 51 & 52 ? (a2 ^ 15 ? 8 ^ Math.random() * (a2 ^ 20 ? 16 : 4) : 4).toString(16) : "-") {
}
return b2;
})();
return result;
}
function getInfuraRpcUrl(chainId, infuraId) {
let rpcUrl;
const network = infuraNetworks[chainId];
if (network) {
rpcUrl = `https://${network}.infura.io/v3/${infuraId}`;
}
return rpcUrl;
}
function getRpcUrl(chainId, rpc) {
let rpcUrl;
const infuraUrl = getInfuraRpcUrl(chainId, rpc.infuraId);
if (rpc.custom && rpc.custom[chainId]) {
rpcUrl = rpc.custom[chainId];
} else if (infuraUrl) {
rpcUrl = infuraUrl;
}
return rpcUrl;
}
function isEmptyString(value) {
return value === "" || typeof value === "string" && value.trim() === "";
}
function isEmptyArray(array) {
return !(array && array.length);
}
function isHexString(value, length) {
return isHexString$1(value, length);
}
function isJsonRpcRequest(object) {
return typeof object.method !== "undefined";
}
function isJsonRpcResponseSuccess(object) {
return typeof object.result !== "undefined";
}
function isJsonRpcResponseError(object) {
return typeof object.error !== "undefined";
}
function isInternalEvent(object) {
return typeof object.event !== "undefined";
}
function isReservedEvent(event) {
return reservedEvents.includes(event) || event.startsWith("wc_");
}
function isSilentPayload(request) {
if (request.method.startsWith("wc_")) {
return true;
}
if (signingMethods.includes(request.method)) {
return false;
}
return true;
}
function toChecksumAddress(address) {
address = removeHexPrefix(address.toLowerCase());
const hash = removeHexPrefix(sha3Exports.keccak_256(convertUtf8ToBuffer(address)));
let checksum = "";
for (let i2 = 0; i2 < address.length; i2++) {
if (parseInt(hash[i2], 16) > 7) {
checksum += address[i2].toUpperCase();
} else {
checksum += address[i2];
}
}
return addHexPrefix(checksum);
}
const isValidAddress = (address) => {
if (!address) {
return false;
} else if (address.toLowerCase().substring(0, 2) !== "0x") {
return false;
} else if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
return false;
} else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
return true;
} else {
return address === toChecksumAddress(address);
}
};
function parsePersonalSign(params) {
if (!isEmptyArray(params) && !isHexString(params[0])) {
params[0] = convertUtf8ToHex(params[0]);
}
return params;
}
function parseTransactionData(txData) {
if (typeof txData.type !== "undefined" && txData.type !== "0")
return txData;
if (typeof txData.from === "undefined" || !isValidAddress(txData.from)) {
throw new Error(`Transaction object must include a valid 'from' value.`);
}
function parseHexValues(value) {
let result = value;
if (typeof value === "number" || typeof value === "string" && !isEmptyString(value)) {
if (!isHexString(value)) {
result = convertNumberToHex(value);
} else if (typeof value === "string") {
result = sanitizeHex(value);
}
}
if (typeof result === "string") {
result = removeHexLeadingZeros(result);
}
return result;
}
const txDataRPC = {
from: sanitizeHex(txData.from),
to: typeof txData.to === "undefined" ? void 0 : sanitizeHex(txData.to),
gasPrice: typeof txData.gasPrice === "undefined" ? "" : parseHexValues(txData.gasPrice),
gas: typeof txData.gas === "undefined" ? typeof txData.gasLimit === "undefined" ? "" : parseHexValues(txData.gasLimit) : parseHexValues(txData.gas),
value: typeof txData.value === "undefined" ? "" : parseHexValues(txData.value),
nonce: typeof txData.nonce === "undefined" ? "" : parseHexValues(txData.nonce),
data: typeof txData.data === "undefined" ? "" : sanitizeHex(txData.data) || "0x"
};
const prunable = ["gasPrice", "gas", "value", "nonce"];
Object.keys(txDataRPC).forEach((key) => {
if ((typeof txDataRPC[key] === "undefined" || typeof txDataRPC[key] === "string" && !txDataRPC[key].trim().length) && prunable.includes(key)) {
delete txDataRPC[key];
}
});
return txDataRPC;
}
function formatRpcError(error) {
const message = error.message || "Failed or Rejected Request";
let code = -32e3;
if (error && !error.code) {
switch (message) {
case "Parse error":
code = -32700;
break;
case "Invalid request":
code = -32600;
break;
case "Method not found":
code = -32601;
break;
case "Invalid params":
code = -32602;
break;
case "Internal error":
code = -32603;
break;
default:
code = -32e3;
break;
}
}
const result = {
code,
message
};
if (error.data) {
result.data = error.data;
}
return result;
}
var queryString = {};
(function(exports) {
const strictUriEncode$1 = strictUriEncode;
const decodeComponent = decodeUriComponent;
const splitOnFirst$1 = splitOnFirst;
const isNullOrUndefined = (value) => value === null || value === void 0;
function encoderForArrayFormat(options) {
switch (options.arrayFormat) {
case "index":
return (key) => (result, value) => {
const index2 = result.length;
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, [encode2(key, options), "[", index2, "]"].join("")];
}
return [
...result,
[encode2(key, options), "[", encode2(index2, options), "]=", encode2(value, options)].join("")
];
};
case "bracket":
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, [encode2(key, options), "[]"].join("")];
}
return [...result, [encode2(key, options), "[]=", encode2(value, options)].join("")];
};
case "comma":
case "separator":
return (key) => (result, value) => {
if (value === null || value === void 0 || value.length === 0) {
return result;
}
if (result.length === 0) {
return [[encode2(key, options), "=", encode2(value, options)].join("")];
}
return [[result, encode2(value, options)].join(options.arrayFormatSeparator)];
};
default:
return (key) => (result, value) => {
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
return result;
}
if (value === null) {
return [...result, encode2(key, options)];
}
return [...result, [encode2(key, options), "=", encode2(value, options)].join("")];
};
}
}
function parserForArrayFormat(options) {
let result;
switch (options.arrayFormat) {
case "index":
return (key, value, accumulator) => {
result = /\[(\d*)\]$/.exec(key);
key = key.replace(/\[\d*\]$/, "");
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === void 0) {
accumulator[key] = {};
}
accumulator[key][result[1]] = value;
};
case "bracket":
return (key, value, accumulator) => {
result = /(\[\])$/.exec(key);
key = key.replace(/\[\]$/, "");
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === void 0) {
accumulator[key] = [value];
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
case "comma":
case "separator":
return (key, value, accumulator) => {
const isArray2 = typeof value === "string" && value.split("").indexOf(options.arrayFormatSeparator) > -1;
const newValue = isArray2 ? value.split(options.arrayFormatSeparator).map((item) => decode(item, options)) : value === null ? value : decode(value, options);
accumulator[key] = newValue;
};
default:
return (key, value, accumulator) => {
if (accumulator[key] === void 0) {
accumulator[key] = value;
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
}
}
function validateArrayFormatSeparator(value) {
if (typeof value !== "string" || value.length !== 1) {
throw new TypeError("arrayFormatSeparator must be single character string");
}
}
function encode2(value, options) {
if (options.encode) {
return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
}
return value;
}
function decode(value, options) {
if (options.decode) {
return decodeComponent(value);
}
return value;
}
function keysSorter(input) {
if (Array.isArray(input)) {
return input.sort();
}
if (typeof input === "object") {
return keysSorter(Object.keys(input)).sort((a2, b2) => Number(a2) - Number(b2)).map((key) => input[key]);
}
return input;
}
function removeHash(input) {
const hashStart = input.indexOf("#");
if (hashStart !== -1) {
input = input.slice(0, hashStart);
}
return input;
}
function getHash(url) {
let hash = "";
const hashStart = url.indexOf("#");
if (hashStart !== -1) {
hash = url.slice(hashStart);
}
return hash;
}
function extract(input) {
input = removeHash(input);
const queryStart = input.indexOf("?");
if (queryStart === -1) {
return "";
}
return input.slice(queryStart + 1);
}
function parseValue(value, options) {
if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
value = Number(value);
} else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
value = value.toLowerCase() === "true";
}
return value;
}
function parse(input, options) {
options = Object.assign({
decode: true,
sort: true,
arrayFormat: "none",
arrayFormatSeparator: ",",
parseNumbers: false,
parseBooleans: false
}, options);
validateArrayFormatSeparator(options.arrayFormatSeparator);
const formatter = parserForArrayFormat(options);
const ret = /* @__PURE__ */ Object.create(null);
if (typeof input !== "string") {
return ret;
}
input = input.trim().replace(/^[?#&]/, "");
if (!input) {
return ret;
}
for (const param of input.split("&")) {
let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, " ") : param, "=");
value = value === void 0 ? null : ["comma", "separator"].includes(options.arrayFormat) ? value : decode(value, options);
formatter(decode(key, options), value, ret);
}
for (const key of Object.keys(ret)) {
const value = ret[key];
if (typeof value === "object" && value !== null) {
for (const k2 of Object.keys(value)) {
value[k2] = parseValue(value[k2], options);
}
} else {
ret[key] = parseValue(value, options);
}
}
if (options.sort === false) {
return ret;
}
return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
const value = ret[key];
if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
result[key] = keysSorter(value);
} else {
result[key] = value;
}
return result;
}, /* @__PURE__ */ Object.create(null));
}
exports.extract = extract;
exports.parse = parse;
exports.stringify = (object, options) => {
if (!object) {
return "";
}
options = Object.assign({
encode: true,
strict: true,
arrayFormat: "none",
arrayFormatSeparator: ","
}, options);
validateArrayFormatSeparator(options.arrayFormatSeparator);
const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
const formatter = encoderForArrayFormat(options);
const objectCopy = {};
for (const key of Object.keys(object)) {
if (!shouldFilter(key)) {
objectCopy[key] = object[key];
}
}
const keys = Object.keys(objectCopy);
if (options.sort !== false) {
keys.sort(options.sort);
}
return keys.map((key) => {
const value = object[key];
if (value === void 0) {
return "";
}
if (value === null) {
return encode2(key, options);
}
if (Array.isArray(value)) {
return value.reduce(formatter(key), []).join("&");
}
return encode2(key, options) + "=" + encode2(value, options);
}).filter((x2) => x2.length > 0).join("&");
};
exports.parseUrl = (input, options) => {
options = Object.assign({
decode: true
}, options);
const [url, hash] = splitOnFirst$1(input, "#");
return Object.assign(
{
url: url.split("?")[0] || "",
query: parse(extract(input), options)
},
options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {}
);
};
exports.stringifyUrl = (input, options) => {
options = Object.assign({
encode: true,
strict: true
}, options);
const url = removeHash(input.url).split("?")[0] || "";
const queryFromUrl = exports.extract(input.url);
const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
const query = Object.assign(parsedQueryFromUrl, input.query);
let queryString2 = exports.stringify(query, options);
if (queryString2) {
queryString2 = `?${queryString2}`;
}
let hash = getHash(input.url);
if (input.fragmentIdentifier) {
hash = `#${encode2(input.fragmentIdentifier, options)}`;
}
return `${url}${queryString2}${hash}`;
};
})(queryString);
function getQueryString(url) {
const pathEnd = url.indexOf("?") !== -1 ? url.indexOf("?") : void 0;
const queryString2 = typeof pathEnd !== "undefined" ? url.substr(pathEnd) : "";
return queryString2;
}
function appendToQueryString(queryString2, newQueryParams) {
let queryParams = parseQueryString(queryString2);
queryParams = Object.assign(Object.assign({}, queryParams), newQueryParams);
queryString2 = formatQueryString(queryParams);
return queryString2;
}
function parseQueryString(queryString$1) {
return queryString.parse(queryString$1);
}
function formatQueryString(queryParams) {
return queryString.stringify(queryParams);
}
function isWalletConnectSession(object) {
return typeof object.bridge !== "undefined";
}
function parseWalletConnectUri(str) {
const pathStart = str.indexOf(":");
const pathEnd = str.indexOf("?") !== -1 ? str.indexOf("?") : void 0;
const protocol = str.substring(0, pathStart);
const path = str.substring(pathStart + 1, pathEnd);
function parseRequiredParams(path2) {
const separator = "@";
const values = path2.split(separator);
const requiredParams2 = {
handshakeTopic: values[0],
version: parseInt(values[1], 10)
};
return requiredParams2;
}
const requiredParams = parseRequiredParams(path);
const queryString2 = typeof pathEnd !== "undefined" ? str.substr(pathEnd) : "";
function parseQueryParams(queryString3) {
const result2 = parseQueryString(queryString3);
const parameters = {
key: result2.key || "",
bridge: result2.bridge || ""
};
return parameters;
}
const queryParams = parseQueryParams(queryString2);
const result = Object.assign(Object.assign({ protocol }, requiredParams), queryParams);
return result;
}
class NetworkMonitor {
constructor() {
this._eventEmitters = [];
if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
window.addEventListener("online", () => this.trigger("online"));
window.addEventListener("offline", () => this.trigger("offline"));
}
}
on(event, callback) {
this._eventEmitters.push({
event,
callback
});
}
trigger(event) {
let eventEmitters = [];
if (event) {
eventEmitters = this._eventEmitters.filter((eventEmitter) => eventEmitter.event === event);
}
eventEmitters.forEach((eventEmitter) => {
eventEmitter.callback();
});
}
}
const WS = typeof global.WebSocket !== "undefined" ? global.WebSocket : require("ws");
class SocketTransport {
constructor(opts) {
this.opts = opts;
this._queue = [];
this._events = [];
this._subscriptions = [];
this._protocol = opts.protocol;
this._version = opts.version;
this._url = "";
this._netMonitor = null;
this._socket = null;
this._nextSocket = null;
this._subscriptions = opts.subscriptions || [];
this._netMonitor = opts.netMonitor || new NetworkMonitor();
if (!opts.url || typeof opts.url !== "string") {
throw new Error("Missing or invalid WebSocket url");
}
this._url = opts.url;
this._netMonitor.on("online", () => this._socketCreate());
}
set readyState(value) {
}
get readyState() {
return this._socket ? this._socket.readyState : -1;
}
set connecting(value) {
}
get connecting() {
return this.readyState === 0;
}
set connected(value) {
}
get connected() {
return this.readyState === 1;
}
set closing(value) {
}
get closing() {
return this.readyState === 2;
}
set closed(value) {
}
get closed() {
return this.readyState === 3;
}
open() {
this._socketCreate();
}
close() {
this._socketClose();
}
send(message, topic, silent) {
if (!topic || typeof topic !== "string") {
throw new Error("Missing or invalid topic field");
}
this._socketSend({
topic,
type: "pub",
payload: message,
silent: !!silent
});
}
subscribe(topic) {
this._socketSend({
topic,
type: "sub",
payload: "",
silent: true
});
}
on(event, callback) {
this._events.push({ event, callback });
}
_socketCreate() {
if (this._nextSocket) {
return;
}
const url = getWebSocketUrl(this._url, this._protocol, this._version);
this._nextSocket = new WS(url);
if (!this._nextSocket) {
throw new Error("Failed to create socket");
}
this._nextSocket.onmessage = (event) => this._socketReceive(event);
this._nextSocket.onopen = () => this._socketOpen();
this._nextSocket.onerror = (event) => this._socketError(event);
this._nextSocket.onclose = () => {
setTimeout(() => {
this._nextSocket = null;
this._socketCreate();
}, 1e3);
};
}
_socketOpen() {
this._socketClose();
this._socket = this._nextSocket;
this._nextSocket = null;
this._queueSubscriptions();
this._pushQueue();
}
_socketClose() {
if (this._socket) {
this._socket.onclose = () => {
};
this._socket.close();
}
}
_socketSend(socketMessage) {
const message = JSON.stringify(socketMessage);
if (this._socket && this._socket.readyState === 1) {
this._socket.send(message);
} else {
this._setToQueue(socketMessage);
this._socketCreate();
}
}
async _socketReceive(event) {
let socketMessage;
try {
socketMessage = JSON.parse(event.data);
} catch (error) {
return;
}
this._socketSend({
topic: socketMessage.topic,
type: "ack",
payload: "",
silent: true
});
if (this._socket && this._socket.readyState === 1) {
const events = this._events.filter((event2) => event2.event === "message");
if (events && events.length) {
events.forEach((event2) => event2.callback(socketMessage));
}
}
}
_socketError(e2) {
const events = this._events.filter((event) => event.event === "error");
if (events && events.length) {
events.forEach((event) => event.callback(e2));
}
}
_queueSubscriptions() {
const subscriptions = this._subscriptions;
subscriptions.forEach((topic) => this._queue.push({
topic,
type: "sub",
payload: "",
silent: true
}));
this._subscriptions = this.opts.subscriptions || [];
}
_setToQueue(socketMessage) {
this._queue.push(socketMessage);
}
_pushQueue() {
const queue = this._queue;
queue.forEach((socketMessage) => this._socketSend(socketMessage));
this._queue = [];
}
}
function getWebSocketUrl(_url, protocol, version2) {
var _a, _b;
const url = _url.startsWith("https") ? _url.replace("https", "wss") : _url.startsWith("http") ? _url.replace("http", "ws") : _url;
const splitUrl = url.split("?");
const params = isBrowser() ? {
protocol,
version: version2,
env: "browser",
host: ((_a = getLocation()) === null || _a === void 0 ? void 0 : _a.host) || ""
} : {
protocol,
version: version2,
env: ((_b = detectEnv()) === null || _b === void 0 ? void 0 : _b.name) || ""
};
const queryString2 = appendToQueryString(getQueryString(splitUrl[1] || ""), params);
return splitUrl[0] + "?" + queryString2;
}
const ERROR_SESSION_CONNECTED = "Session currently connected";
const ERROR_SESSION_DISCONNECTED = "Session currently disconnected";
const ERROR_SESSION_REJECTED = "Session Rejected";
const ERROR_MISSING_JSON_RPC = "Missing JSON RPC response";
const ERROR_MISSING_RESULT = `JSON-RPC success response must include "result" field`;
const ERROR_MISSING_ERROR = `JSON-RPC error response must include "error" field`;
const ERROR_MISSING_METHOD = `JSON RPC request must have valid "method" value`;
const ERROR_MISSING_ID = `JSON RPC request must have valid "id" value`;
const ERROR_MISSING_REQUIRED = "Missing one of the required parameters: bridge / uri / session";
const ERROR_INVALID_RESPONSE = "JSON RPC response format is invalid";
const ERROR_INVALID_URI = "URI format is invalid";
const ERROR_QRCODE_MODAL_NOT_PROVIDED = "QRCode Modal not provided";
const ERROR_QRCODE_MODAL_USER_CLOSED = "User close QRCode Modal";
class EventManager {
constructor() {
this._eventEmitters = [];
}
subscribe(eventEmitter) {
this._eventEmitters.push(eventEmitter);
}
unsubscribe(event) {
this._eventEmitters = this._eventEmitters.filter((x2) => x2.event !== event);
}
trigger(payload) {
let eventEmitters = [];
let event;
if (isJsonRpcRequest(payload)) {
event = payload.method;
} else if (isJsonRpcResponseSuccess(payload) || isJsonRpcResponseError(payload)) {
event = `response:${payload.id}`;
} else if (isInternalEvent(payload)) {
event = payload.event;
} else {
event = "";
}
if (event) {
eventEmitters = this._eventEmitters.filter((eventEmitter) => eventEmitter.event === event);
}
if ((!eventEmitters || !eventEmitters.length) && !isReservedEvent(event) && !isInternalEvent(event)) {
eventEmitters = this._eventEmitters.filter((eventEmitter) => eventEmitter.event === "call_request");
}
eventEmitters.forEach((eventEmitter) => {
if (isJsonRpcResponseError(payload)) {
const error = new Error(payload.error.message);
eventEmitter.callback(error, null);
} else {
eventEmitter.callback(null, payload);
}
});
}
}
class SessionStorage {
constructor(storageId = "walletconnect") {
this.storageId = storageId;
}
getSession() {
let session = null;
const json = getLocal(this.storageId);
if (json && isWalletConnectSession(json)) {
session = json;
}
return session;
}
setSession(session) {
setLocal(this.storageId, session);
return session;
}
removeSession() {
removeLocal(this.storageId);
}
}
const domain = "walletconnect.org";
const alphanumerical = "abcdefghijklmnopqrstuvwxyz0123456789";
const bridges = alphanumerical.split("").map((char) => `https://${char}.bridge.walletconnect.org`);
function extractHostname(url) {
let hostname = url.indexOf("//") > -1 ? url.split("/")[2] : url.split("/")[0];
hostname = hostname.split(":")[0];
hostname = hostname.split("?")[0];
return hostname;
}
function extractRootDomain(url) {
return extractHostname(url).split(".").slice(-2).join(".");
}
function randomBridgeIndex() {
return Math.floor(Math.random() * bridges.length);
}
function selectRandomBridgeUrl() {
return bridges[randomBridgeIndex()];
}
function shouldSelectRandomly(url) {
return extractRootDomain(url) === domain;
}
function getBridgeUrl(url) {
if (shouldSelectRandomly(url)) {
return selectRandomBridgeUrl();
}
return url;
}
class Connector {
constructor(opts) {
this.protocol = "wc";
this.version = 1;
this._bridge = "";
this._key = null;
this._clientId = "";
this._clientMeta = null;
this._peerId = "";
this._peerMeta = null;
this._handshakeId = 0;
this._handshakeTopic = "";
this._connected = false;
this._accounts = [];
this._chainId = 0;
this._networkId = 0;
this._rpcUrl = "";
this._eventManager = new EventManager();
this._clientMeta = getClientMeta() || opts.connectorOpts.clientMeta || null;
this._cryptoLib = opts.cryptoLib;
this._sessionStorage = opts.sessionStorage || new SessionStorage(opts.connectorOpts.storageId);
this._qrcodeModal = opts.connectorOpts.qrcodeModal;
this._qrcodeModalOptions = opts.connectorOpts.qrcodeModalOptions;
this._signingMethods = [...signingMethods, ...opts.connectorOpts.signingMethods || []];
if (!opts.connectorOpts.bridge && !opts.connectorOpts.uri && !opts.connectorOpts.session) {
throw new Error(ERROR_MISSING_REQUIRED);
}
if (opts.connectorOpts.bridge) {
this.bridge = getBridgeUrl(opts.connectorOpts.bridge);
}
if (opts.connectorOpts.uri) {
this.uri = opts.connectorOpts.uri;
}
const session = opts.connectorOpts.session || this._getStorageSession();
if (session) {
this.session = session;
}
if (this.handshakeId) {
this._subscribeToSessionResponse(this.handshakeId, "Session request rejected");
}
this._transport = opts.transport || new SocketTransport({
protocol: this.protocol,
version: this.version,
url: this.bridge,
subscriptions: [this.clientId]
});
this._subscribeToInternalEvents();
this._initTransport();
if (opts.connectorOpts.uri) {
this._subscribeToSessionRequest();
}
if (opts.pushServerOpts) {
this._registerPushServer(opts.pushServerOpts);
}
}
set bridge(value) {
if (!value) {
return;
}
this._bridge = value;
}
get bridge() {
return this._bridge;
}
set key(value) {
if (!value) {
return;
}
const key = convertHexToArrayBuffer(value);
this._key = key;
}
get key() {
if (this._key) {
const key = convertArrayBufferToHex(this._key, true);
return key;
}
return "";
}
set clientId(value) {
if (!value) {
return;
}
this._clientId = value;
}
get clientId() {
let clientId = this._clientId;
if (!clientId) {
clientId = this._clientId = uuid();
}
return this._clientId;
}
set peerId(value) {
if (!value) {
return;
}
this._peerId = value;
}
get peerId() {
return this._peerId;
}
set clientMeta(value) {
}
get clientMeta() {
let clientMeta = this._clientMeta;
if (!clientMeta) {
clientMeta = this._clientMeta = getClientMeta();
}
return clientMeta;
}
set peerMeta(value) {
this._peerMeta = value;
}
get peerMeta() {
const peerMeta = this._peerMeta;
return peerMeta;
}
set handshakeTopic(value) {
if (!value) {
return;
}
this._handshakeTopic = value;
}
get handshakeTopic() {
return this._handshakeTopic;
}
set handshakeId(value) {
if (!value) {
return;
}
this._handshakeId = value;
}
get handshakeId() {
return this._handshakeId;
}
get uri() {
const _uri = this._formatUri();
return _uri;
}
set uri(value) {
if (!value) {
return;
}
const { handshakeTopic, bridge, key } = this._parseUri(value);
this.handshakeTopic = handshakeTopic;
this.bridge = bridge;
this.key = key;
}
set chainId(value) {
this._chainId = value;
}
get chainId() {
const chainId = this._chainId;
return chainId;
}
set networkId(value) {
this._networkId = value;
}
get networkId() {
const networkId = this._networkId;
return networkId;
}
set accounts(value) {
this._accounts = value;
}
get accounts() {
const accounts = this._accounts;
return accounts;
}
set rpcUrl(value) {
this._rpcUrl = value;
}
get rpcUrl() {
const rpcUrl = this._rpcUrl;
return rpcUrl;
}
set connected(value) {
}
get connected() {
return this._connected;
}
set pending(value) {
}
get pending() {
return !!this._handshakeTopic;
}
get session() {
return {
connected: this.connected,
accounts: this.accounts,
chainId: this.chainId,
bridge: this.bridge,
key: this.key,
clientId: this.clientId,
clientMeta: this.clientMeta,
peerId: this.peerId,
peerMeta: this.peerMeta,
handshakeId: this.handshakeId,
handshakeTopic: this.handshakeTopic
};
}
set session(value) {
if (!value) {
return;
}
this._connected = value.connected;
this.accounts = value.accounts;
this.chainId = value.chainId;
this.bridge = value.bridge;
this.key = value.key;
this.clientId = value.clientId;
this.clientMeta = value.clientMeta;
this.peerId = value.peerId;
this.peerMeta = value.peerMeta;
this.handshakeId = value.handshakeId;
this.handshakeTopic = value.handshakeTopic;
}
on(event, callback) {
const eventEmitter = {
event,
callback
};
this._eventManager.subscribe(eventEmitter);
}
off(event) {
this._eventManager.unsubscribe(event);
}
async createInstantRequest(instantRequest) {
this._key = await this._generateKey();
const request = this._formatRequest({
method: "wc_instantRequest",
params: [
{
peerId: this.clientId,
peerMeta: this.clientMeta,
request: this._formatRequest(instantRequest)
}
]
});
this.handshakeId = request.id;
this.handshakeTopic = uuid();
this._eventManager.trigger({
event: "display_uri",
params: [this.uri]
});
this.on("modal_closed", () => {
throw new Error(ERROR_QRCODE_MODAL_USER_CLOSED);
});
const endInstantRequest = () => {
this.killSession();
};
try {
const result = await this._sendCallRequest(request);
if (result) {
endInstantRequest();
}
return result;
} catch (error) {
endInstantRequest();
throw error;
}
}
async connect(opts) {
if (!this._qrcodeModal) {
throw new Error(ERROR_QRCODE_MODAL_NOT_PROVIDED);
}
if (this.connected) {
return {
chainId: this.chainId,
accounts: this.accounts
};
}
await this.createSession(opts);
return new Promise(async (resolve, reject) => {
this.on("modal_closed", () => reject(new Error(ERROR_QRCODE_MODAL_USER_CLOSED)));
this.on("connect", (error, payload) => {
if (error) {
return reject(error);
}
resolve(payload.params[0]);
});
});
}
async createSession(opts) {
if (this._connected) {
throw new Error(ERROR_SESSION_CONNECTED);
}
if (this.pending) {
return;
}
this._key = await this._generateKey();
const request = this._formatRequest({
method: "wc_sessionRequest",
params: [
{
peerId: this.clientId,
peerMeta: this.clientMeta,
chainId: opts && opts.chainId ? opts.chainId : null
}
]
});
this.handshakeId = request.id;
this.handshakeTopic = uuid();
this._sendSessionRequest(request, "Session update rejected", {
topic: this.handshakeTopic
});
this._eventManager.trigger({
event: "display_uri",
params: [this.uri]
});
}
approveSession(sessionStatus) {
if (this._connected) {
throw new Error(ERROR_SESSION_CONNECTED);
}
this.chainId = sessionStatus.chainId;
this.accounts = sessionStatus.accounts;
this.networkId = sessionStatus.networkId || 0;
this.rpcUrl = sessionStatus.rpcUrl || "";
const sessionParams = {
approved: true,
chainId: this.chainId,
networkId: this.networkId,
accounts: this.accounts,
rpcUrl: this.rpcUrl,
peerId: this.clientId,
peerMeta: this.clientMeta
};
const response = {
id: this.handshakeId,
jsonrpc: "2.0",
result: sessionParams
};
this._sendResponse(response);
this._connected = true;
this._setStorageSession();
this._eventManager.trigger({
event: "connect",
params: [
{
peerId: this.peerId,
peerMeta: this.peerMeta,
chainId: this.chainId,
accounts: this.accounts
}
]
});
}
rejectSession(sessionError) {
if (this._connected) {
throw new Error(ERROR_SESSION_CONNECTED);
}
const message = sessionError && sessionError.message ? sessionError.message : ERROR_SESSION_REJECTED;
const response = this._formatResponse({
id: this.handshakeId,
error: { message }
});
this._sendResponse(response);
this._connected = false;
this._eventManager.trigger({
event: "disconnect",
params: [{ message }]
});
this._removeStorageSession();
}
updateSession(sessionStatus) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
this.chainId = sessionStatus.chainId;
this.accounts = sessionStatus.accounts;
this.networkId = sessionStatus.networkId || 0;
this.rpcUrl = sessionStatus.rpcUrl || "";
const sessionParams = {
approved: true,
chainId: this.chainId,
networkId: this.networkId,
accounts: this.accounts,
rpcUrl: this.rpcUrl
};
const request = this._formatRequest({
method: "wc_sessionUpdate",
params: [sessionParams]
});
this._sendSessionRequest(request, "Session update rejected");
this._eventManager.trigger({
event: "session_update",
params: [
{
chainId: this.chainId,
accounts: this.accounts
}
]
});
this._manageStorageSession();
}
async killSession(sessionError) {
const message = sessionError ? sessionError.message : "Session Disconnected";
const sessionParams = {
approved: false,
chainId: null,
networkId: null,
accounts: null
};
const request = this._formatRequest({
method: "wc_sessionUpdate",
params: [sessionParams]
});
await this._sendRequest(request);
this._handleSessionDisconnect(message);
}
async sendTransaction(tx) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
const parsedTx = parseTransactionData(tx);
const request = this._formatRequest({
method: "eth_sendTransaction",
params: [parsedTx]
});
const result = await this._sendCallRequest(request);
return result;
}
async signTransaction(tx) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
const parsedTx = parseTransactionData(tx);
const request = this._formatRequest({
method: "eth_signTransaction",
params: [parsedTx]
});
const result = await this._sendCallRequest(request);
return result;
}
async signMessage(params) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
const request = this._formatRequest({
method: "eth_sign",
params
});
const result = await this._sendCallRequest(request);
return result;
}
async signPersonalMessage(params) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
params = parsePersonalSign(params);
const request = this._formatRequest({
method: "personal_sign",
params
});
const result = await this._sendCallRequest(request);
return result;
}
async signTypedData(params) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
const request = this._formatRequest({
method: "eth_signTypedData",
params
});
const result = await this._sendCallRequest(request);
return result;
}
async updateChain(chainParams) {
if (!this._connected) {
throw new Error("Session currently disconnected");
}
const request = this._formatRequest({
method: "wallet_updateChain",
params: [chainParams]
});
const result = await this._sendCallRequest(request);
return result;
}
unsafeSend(request, options) {
this._sendRequest(request, options);
this._eventManager.trigger({
event: "call_request_sent",
params: [{ request, options }]
});
return new Promise((resolve, reject) => {
this._subscribeToResponse(request.id, (error, payload) => {
if (error) {
reject(error);
return;
}
if (!payload) {
throw new Error(ERROR_MISSING_JSON_RPC);
}
resolve(payload);
});
});
}
async sendCustomRequest(request, options) {
if (!this._connected) {
throw new Error(ERROR_SESSION_DISCONNECTED);
}
switch (request.method) {
case "eth_accounts":
return this.accounts;
case "eth_chainId":
return convertNumberToHex(this.chainId);
case "eth_sendTransaction":
case "eth_signTransaction":
if (request.params) {
request.params[0] = parseTransactionData(request.params[0]);
}
break;
case "personal_sign":
if (request.params) {
request.params = parsePersonalSign(request.params);
}
break;
}
const formattedRequest = this._formatRequest(request);
const result = await this._sendCallRequest(formattedRequest, options);
return result;
}
approveRequest(response) {
if (isJsonRpcResponseSuccess(response)) {
const formattedResponse = this._formatResponse(response);
this._sendResponse(formattedResponse);
} else {
throw new Error(ERROR_MISSING_RESULT);
}
}
rejectRequest(response) {
if (isJsonRpcResponseError(response)) {
const formattedResponse = this._formatResponse(response);
this._sendResponse(formattedResponse);
} else {
throw new Error(ERROR_MISSING_ERROR);
}
}
transportClose() {
this._transport.close();
}
async _sendRequest(request, options) {
const callRequest = this._formatRequest(request);
const encryptionPayload = await this._encrypt(callRequest);
const topic = typeof (options === null || options === void 0 ? void 0 : options.topic) !== "undefined" ? options.topic : this.peerId;
const payload = JSON.stringify(encryptionPayload);
const silent = typeof (options === null || options === void 0 ? void 0 : options.forcePushNotification) !== "undefined" ? !options.forcePushNotification : isSilentPayload(callRequest);
this._transport.send(payload, topic, silent);
}
async _sendResponse(response) {
const encryptionPayload = await this._encrypt(response);
const topic = this.peerId;
const payload = JSON.stringify(encryptionPayload);
const silent = true;
this._transport.send(payload, topic, silent);
}
async _sendSessionRequest(request, errorMsg, options) {
this._sendRequest(request, options);
this._subscribeToSessionResponse(request.id, errorMsg);
}
_sendCallRequest(request, options) {
this._sendRequest(request, options);
this._eventManager.trigger({
event: "call_request_sent",
params: [{ request, options }]
});
return this._subscribeToCallResponse(request.id);
}
_formatRequest(request) {
if (typeof request.method === "undefined") {
throw new Error(ERROR_MISSING_METHOD);
}
const formattedRequest = {
id: typeof request.id === "undefined" ? payloadId() : request.id,
jsonrpc: "2.0",
method: request.method,
params: typeof request.params === "undefined" ? [] : request.params
};
return formattedRequest;
}
_formatResponse(response) {
if (typeof response.id === "undefined") {
throw new Error(ERROR_MISSING_ID);
}
const baseResponse = { id: response.id, jsonrpc: "2.0" };
if (isJsonRpcResponseError(response)) {
const error = formatRpcError(response.error);
const errorResponse = Object.assign(Object.assign(Object.assign({}, baseResponse), response), { error });
return errorResponse;
} else if (isJsonRpcResponseSuccess(response)) {
const successResponse = Object.assign(Object.assign({}, baseResponse), response);
return successResponse;
}
throw new Error(ERROR_INVALID_RESPONSE);
}
_handleSessionDisconnect(errorMsg) {
const message = errorMsg || "Session Disconnected";
if (!this._connected) {
if (this._qrcodeModal) {
this._qrcodeModal.close();
}
removeLocal(mobileLinkChoiceKey);
}
if (this._connected) {
this._connected = false;
}
if (this._handshakeId) {
this._handshakeId = 0;
}
if (this._handshakeTopic) {
this._handshakeTopic = "";
}
if (this._peerId) {
this._peerId = "";
}
this._eventManager.trigger({
event: "disconnect",
params: [{ message }]
});
this._removeStorageSession();
this.transportClose();
}
_handleSessionResponse(errorMsg, sessionParams) {
if (sessionParams) {
if (sessionParams.approved) {
if (!this._connected) {
this._connected = true;
if (sessionParams.chainId) {
this.chainId = sessionParams.chainId;
}
if (sessionParams.accounts) {
this.accounts = sessionParams.accounts;
}
if (sessionParams.peerId && !this.peerId) {
this.peerId = sessionParams.peerId;
}
if (sessionParams.peerMeta && !this.peerMeta) {
this.peerMeta = sessionParams.peerMeta;
}
this._eventManager.trigger({
event: "connect",
params: [
{
peerId: this.peerId,
peerMeta: this.peerMeta,
chainId: this.chainId,
accounts: this.accounts
}
]
});
} else {
if (sessionParams.chainId) {
this.chainId = sessionParams.chainId;
}
if (sessionParams.accounts) {
this.accounts = sessionParams.accounts;
}
this._eventManager.trigger({
event: "session_update",
params: [
{
chainId: this.chainId,
accounts: this.accounts
}
]
});
}
this._manageStorageSession();
} else {
this._handleSessionDisconnect(errorMsg);
}
} else {
this._handleSessionDisconnect(errorMsg);
}
}
async _handleIncomingMessages(socketMessage) {
const activeTopics = [this.clientId, this.handshakeTopic];
if (!activeTopics.includes(socketMessage.topic)) {
return;
}
let encryptionPayload;
try {
encryptionPayload = JSON.parse(socketMessage.payload);
} catch (error) {
return;
}
const payload = await this._decrypt(encryptionPayload);
if (payload) {
this._eventManager.trigger(payload);
}
}
_subscribeToSessionRequest() {
this._transport.subscribe(this.handshakeTopic);
}
_subscribeToResponse(id, callback) {
this.on(`response:${id}`, callback);
}
_subscribeToSessionResponse(id, errorMsg) {
this._subscribeToResponse(id, (error, payload) => {
if (error) {
this._handleSessionResponse(error.message);
return;
}
if (isJsonRpcResponseSuccess(payload)) {
this._handleSessionResponse(errorMsg, payload.result);
} else if (payload.error && payload.error.message) {
this._handleSessionResponse(payload.error.message);
} else {
this._handleSessionResponse(errorMsg);
}
});
}
_subscribeToCallResponse(id) {
return new Promise((resolve, reject) => {
this._subscribeToResponse(id, (error, payload) => {
if (error) {
reject(error);
return;
}
if (isJsonRpcResponseSuccess(payload)) {
resolve(payload.result);
} else if (payload.error && payload.error.message) {
reject(payload.error);
} else {
reject(new Error(ERROR_INVALID_RESPONSE));
}
});
});
}
_subscribeToInternalEvents() {
this.on("display_uri", () => {
if (this._qrcodeModal) {
this._qrcodeModal.open(this.uri, () => {
this._eventManager.trigger({
event: "modal_closed",
params: []
});
}, this._qrcodeModalOptions);
}
});
this.on("connect", () => {
if (this._qrcodeModal) {
this._qrcodeModal.close();
}
});
this.on("call_request_sent", (error, payload) => {
const { request } = payload.params[0];
if (isMobile() && this._signingMethods.includes(request.method)) {
const mobileLinkUrl = getLocal(mobileLinkChoiceKey);
if (mobileLinkUrl) {
window.location.href = mobileLinkUrl.href;
}
}
});
this.on("wc_sessionRequest", (error, payload) => {
if (error) {
this._eventManager.trigger({
event: "error",
params: [
{
code: "SESSION_REQUEST_ERROR",
message: error.toString()
}
]
});
}
this.handshakeId = payload.id;
this.peerId = payload.params[0].peerId;
this.peerMeta = payload.params[0].peerMeta;
const internalPayload = Object.assign(Object.assign({}, payload), { method: "session_request" });
this._eventManager.trigger(internalPayload);
});
this.on("wc_sessionUpdate", (error, payload) => {
if (error) {
this._handleSessionResponse(error.message);
}
this._handleSessionResponse("Session disconnected", payload.params[0]);
});
}
_initTransport() {
this._transport.on("message", (socketMessage) => this._handleIncomingMessages(socketMessage));
this._transport.on("open", () => this._eventManager.trigger({ event: "transport_open", params: [] }));
this._transport.on("close", () => this._eventManager.trigger({ event: "transport_close", params: [] }));
this._transport.on("error", () => this._eventManager.trigger({
event: "transport_error",
params: ["Websocket connection failed"]
}));
this._transport.open();
}
_formatUri() {
const protocol = this.protocol;
const handshakeTopic = this.handshakeTopic;
const version2 = this.version;
const bridge = encodeURIComponent(this.bridge);
const key = this.key;
const uri = `${protocol}:${handshakeTopic}@${version2}?bridge=${bridge}&key=${key}`;
return uri;
}
_parseUri(uri) {
const result = parseWalletConnectUri(uri);
if (result.protocol === this.protocol) {
if (!result.handshakeTopic) {
throw Error("Invalid or missing handshakeTopic parameter value");
}
const handshakeTopic = result.handshakeTopic;
if (!result.bridge) {
throw Error("Invalid or missing bridge url parameter value");
}
const bridge = decodeURIComponent(result.bridge);
if (!result.key) {
throw Error("Invalid or missing key parameter value");
}
const key = result.key;
return { handshakeTopic, bridge, key };
} else {
throw new Error(ERROR_INVALID_URI);
}
}
async _generateKey() {
if (this._cryptoLib) {
const result = await this._cryptoLib.generateKey();
return result;
}
return null;
}
async _encrypt(data) {
const key = this._key;
if (this._cryptoLib && key) {
const result = await this._cryptoLib.encrypt(data, key);
return result;
}
return null;
}
async _decrypt(payload) {
const key = this._key;
if (this._cryptoLib && key) {
const result = await this._cryptoLib.decrypt(payload, key);
return result;
}
return null;
}
_getStorageSession() {
let result = null;
if (this._sessionStorage) {
result = this._sessionStorage.getSession();
}
return result;
}
_setStorageSession() {
if (this._sessionStorage) {
this._sessionStorage.setSession(this.session);
}
}
_removeStorageSession() {
if (this._sessionStorage) {
this._sessionStorage.removeSession();
}
}
_manageStorageSession() {
if (this._connected) {
this._setStorageSession();
} else {
this._removeStorageSession();
}
}
_registerPushServer(pushServerOpts) {
if (!pushServerOpts.url || typeof pushServerOpts.url !== "string") {
throw Error("Invalid or missing pushServerOpts.url parameter value");
}
if (!pushServerOpts.type || typeof pushServerOpts.type !== "string") {
throw Error("Invalid or missing pushServerOpts.type parameter value");
}
if (!pushServerOpts.token || typeof pushServerOpts.token !== "string") {
throw Error("Invalid or missing pushServerOpts.token parameter value");
}
const pushSubscription = {
bridge: this.bridge,
topic: this.clientId,
type: pushServerOpts.type,
token: pushServerOpts.token,
peerName: "",
language: pushServerOpts.language || ""
};
this.on("connect", async (error, payload) => {
if (error) {
throw error;
}
if (pushServerOpts.peerMeta) {
const peerName = payload.params[0].peerMeta.name;
pushSubscription.peerName = peerName;
}
try {
const response = await fetch(`${pushServerOpts.url}/new`, {
method: "POST",
headers: {
Accept: "application/json",
"Content-Type": "application/json"
},
body: JSON.stringify(pushSubscription)
});
const json = await response.json();
if (!json.success) {
throw Error("Failed to register in Push Server");
}
} catch (error2) {
throw Error("Failed to register in Push Server");
}
});
}
}
function randomBytes(length) {
const browserCrypto = cjs$3.getBrowerCrypto();
return browserCrypto.getRandomValues(new Uint8Array(length));
}
const LENGTH_256 = 256;
const AES_LENGTH = LENGTH_256;
const HMAC_LENGTH = LENGTH_256;
const AES_BROWSER_ALGO = "AES-CBC";
const HMAC_BROWSER_ALGO = `SHA-${AES_LENGTH}`;
const HMAC_BROWSER = "HMAC";
const ENCRYPT_OP = "encrypt";
const DECRYPT_OP = "decrypt";
const SIGN_OP = "sign";
const VERIFY_OP = "verify";
function getAlgo(type) {
return type === AES_BROWSER_ALGO ? { length: AES_LENGTH, name: AES_BROWSER_ALGO } : {
hash: { name: HMAC_BROWSER_ALGO },
name: HMAC_BROWSER
};
}
function getOps(type) {
return type === AES_BROWSER_ALGO ? [ENCRYPT_OP, DECRYPT_OP] : [SIGN_OP, VERIFY_OP];
}
async function browserImportKey(buffer2, type = AES_BROWSER_ALGO) {
return cjs$3.getSubtleCrypto().importKey("raw", buffer2, getAlgo(type), true, getOps(type));
}
async function browserAesEncrypt(iv, key, data) {
const subtle = cjs$3.getSubtleCrypto();
const cryptoKey = await browserImportKey(key, AES_BROWSER_ALGO);
const result = await subtle.encrypt({
iv,
name: AES_BROWSER_ALGO
}, cryptoKey, data);
return new Uint8Array(result);
}
async function browserAesDecrypt(iv, key, data) {
const subtle = cjs$3.getSubtleCrypto();
const cryptoKey = await browserImportKey(key, AES_BROWSER_ALGO);
const result = await subtle.decrypt({
iv,
name: AES_BROWSER_ALGO
}, cryptoKey, data);
return new Uint8Array(result);
}
async function browserHmacSha256Sign(key, data) {
const subtle = cjs$3.getSubtleCrypto();
const cryptoKey = await browserImportKey(key, HMAC_BROWSER);
const signature = await subtle.sign({
length: HMAC_LENGTH,
name: HMAC_BROWSER
}, cryptoKey, data);
return new Uint8Array(signature);
}
function aesCbcEncrypt(iv, key, data) {
return browserAesEncrypt(iv, key, data);
}
function aesCbcDecrypt(iv, key, data) {
return browserAesDecrypt(iv, key, data);
}
async function hmacSha256Sign(key, msg) {
const result = await browserHmacSha256Sign(key, msg);
return result;
}
async function generateKey(length) {
const _length = (length || 256) / 8;
const bytes = randomBytes(_length);
const result = convertBufferToArrayBuffer(arrayToBuffer(bytes));
return result;
}
async function verifyHmac(payload, key) {
const cipherText = hexToArray(payload.data);
const iv = hexToArray(payload.iv);
const hmac = hexToArray(payload.hmac);
const hmacHex = arrayToHex(hmac, false);
const unsigned = concatArrays(cipherText, iv);
const chmac = await hmacSha256Sign(key, unsigned);
const chmacHex = arrayToHex(chmac, false);
if (removeHexPrefix(hmacHex) === removeHexPrefix(chmacHex)) {
return true;
}
return false;
}
async function encrypt(data, key, providedIv) {
const _key = bufferToArray(convertArrayBufferToBuffer(key));
const ivArrayBuffer = providedIv || await generateKey(128);
const iv = bufferToArray(convertArrayBufferToBuffer(ivArrayBuffer));
const ivHex = arrayToHex(iv, false);
const contentString = JSON.stringify(data);
const content = utf8ToArray(contentString);
const cipherText = await aesCbcEncrypt(iv, _key, content);
const cipherTextHex = arrayToHex(cipherText, false);
const unsigned = concatArrays(cipherText, iv);
const hmac = await hmacSha256Sign(_key, unsigned);
const hmacHex = arrayToHex(hmac, false);
return {
data: cipherTextHex,
hmac: hmacHex,
iv: ivHex
};
}
async function decrypt(payload, key) {
const _key = bufferToArray(convertArrayBufferToBuffer(key));
if (!_key) {
throw new Error("Missing key: required for decryption");
}
const verified = await verifyHmac(payload, _key);
if (!verified) {
return null;
}
const cipherText = hexToArray(payload.data);
const iv = hexToArray(payload.iv);
const buffer2 = await aesCbcDecrypt(iv, _key, cipherText);
const utf8 = arrayToUtf8(buffer2);
let data;
try {
data = JSON.parse(utf8);
} catch (error) {
return null;
}
return data;
}
const cryptoLib = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
__proto__: null,
decrypt,
encrypt,
generateKey,
verifyHmac
}, Symbol.toStringTag, { value: "Module" }));
class WalletConnect extends Connector {
constructor(connectorOpts, pushServerOpts) {
super({
cryptoLib,
connectorOpts,
pushServerOpts
});
}
}
const require$$0 = /* @__PURE__ */ getAugmentedNamespace(esm);
var browser = {};
var canPromise$1 = function() {
return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
};
var qrcode = {};
var typedarrayBuffer = {};
var toString = {}.toString;
var isarray = Array.isArray || function(arr) {
return toString.call(arr) == "[object Array]";
};
var isArray$1 = isarray;
function typedArraySupport() {
try {
var arr = new Uint8Array(1);
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function() {
return 42;
} };
return arr.foo() === 42;
} catch (e2) {
return false;
}
}
Buffer$2.TYPED_ARRAY_SUPPORT = typedArraySupport();
var K_MAX_LENGTH = Buffer$2.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;
function Buffer$2(arg, offset, length) {
if (!Buffer$2.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$2)) {
return new Buffer$2(arg, offset, length);
}
if (typeof arg === "number") {
return allocUnsafe(this, arg);
}
return from(this, arg, offset, length);
}
if (Buffer$2.TYPED_ARRAY_SUPPORT) {
Buffer$2.prototype.__proto__ = Uint8Array.prototype;
Buffer$2.__proto__ = Uint8Array;
if (typeof Symbol !== "undefined" && Symbol.species && Buffer$2[Symbol.species] === Buffer$2) {
Object.defineProperty(Buffer$2, Symbol.species, {
value: null,
configurable: true,
enumerable: false,
writable: false
});
}
}
function checked(length) {
if (length >= K_MAX_LENGTH) {
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
}
return length | 0;
}
function isnan(val) {
return val !== val;
}
function createBuffer(that, length) {
var buf;
if (Buffer$2.TYPED_ARRAY_SUPPORT) {
buf = new Uint8Array(length);
buf.__proto__ = Buffer$2.prototype;
} else {
buf = that;
if (buf === null) {
buf = new Buffer$2(length);
}
buf.length = length;
}
return buf;
}
function allocUnsafe(that, size) {
var buf = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
if (!Buffer$2.TYPED_ARRAY_SUPPORT) {
for (var i2 = 0; i2 < size; ++i2) {
buf[i2] = 0;
}
}
return buf;
}
function fromString(that, string) {
var length = byteLength(string) | 0;
var buf = createBuffer(that, length);
var actual = buf.write(string);
if (actual !== length) {
buf = buf.slice(0, actual);
}
return buf;
}
function fromArrayLike(that, array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0;
var buf = createBuffer(that, length);
for (var i2 = 0; i2 < length; i2 += 1) {
buf[i2] = array[i2] & 255;
}
return buf;
}
function fromArrayBuffer(that, array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError("'offset' is out of bounds");
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError("'length' is out of bounds");
}
var buf;
if (byteOffset === void 0 && length === void 0) {
buf = new Uint8Array(array);
} else if (length === void 0) {
buf = new Uint8Array(array, byteOffset);
} else {
buf = new Uint8Array(array, byteOffset, length);
}
if (Buffer$2.TYPED_ARRAY_SUPPORT) {
buf.__proto__ = Buffer$2.prototype;
} else {
buf = fromArrayLike(that, buf);
}
return buf;
}
function fromObject(that, obj) {
if (Buffer$2.isBuffer(obj)) {
var len = checked(obj.length) | 0;
var buf = createBuffer(that, len);
if (buf.length === 0) {
return buf;
}
obj.copy(buf, 0, 0, len);
return buf;
}
if (obj) {
if (typeof ArrayBuffer !== "undefined" && obj.buffer instanceof ArrayBuffer || "length" in obj) {
if (typeof obj.length !== "number" || isnan(obj.length)) {
return createBuffer(that, 0);
}
return fromArrayLike(that, obj);
}
if (obj.type === "Buffer" && Array.isArray(obj.data)) {
return fromArrayLike(that, obj.data);
}
}
throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.");
}
function utf8ToBytes(string, units) {
units = units || Infinity;
var codePoint;
var length = string.length;
var leadSurrogate = null;
var bytes = [];
for (var i2 = 0; i2 < length; ++i2) {
codePoint = string.charCodeAt(i2);
if (codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
} else if (i2 + 1 === length) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else if (leadSurrogate) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
}
leadSurrogate = null;
if (codePoint < 128) {
if ((units -= 1) < 0)
break;
bytes.push(codePoint);
} else if (codePoint < 2048) {
if ((units -= 2) < 0)
break;
bytes.push(
codePoint >> 6 | 192,
codePoint & 63 | 128
);
} else if (codePoint < 65536) {
if ((units -= 3) < 0)
break;
bytes.push(
codePoint >> 12 | 224,
codePoint >> 6 & 63 | 128,
codePoint & 63 | 128
);
} else if (codePoint < 1114112) {
if ((units -= 4) < 0)
break;
bytes.push(
codePoint >> 18 | 240,
codePoint >> 12 & 63 | 128,
codePoint >> 6 & 63 | 128,
codePoint & 63 | 128
);
} else {
throw new Error("Invalid code point");
}
}
return bytes;
}
function byteLength(string) {
if (Buffer$2.isBuffer(string)) {
return string.length;
}
if (typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
return string.byteLength;
}
if (typeof string !== "string") {
string = "" + string;
}
var len = string.length;
if (len === 0)
return 0;
return utf8ToBytes(string).length;
}
function blitBuffer(src, dst, offset, length) {
for (var i2 = 0; i2 < length; ++i2) {
if (i2 + offset >= dst.length || i2 >= src.length)
break;
dst[i2 + offset] = src[i2];
}
return i2;
}
function utf8Write(buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function from(that, value, offset, length) {
if (typeof value === "number") {
throw new TypeError('"value" argument must not be a number');
}
if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
return fromArrayBuffer(that, value, offset, length);
}
if (typeof value === "string") {
return fromString(that, value);
}
return fromObject(that, value);
}
Buffer$2.prototype.write = function write(string, offset, length) {
if (offset === void 0) {
length = this.length;
offset = 0;
} else if (length === void 0 && typeof offset === "string") {
length = this.length;
offset = 0;
} else if (isFinite(offset)) {
offset = offset | 0;
if (isFinite(length)) {
length = length | 0;
} else {
length = void 0;
}
}
var remaining = this.length - offset;
if (length === void 0 || length > remaining)
length = remaining;
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
throw new RangeError("Attempt to write outside buffer bounds");
}
return utf8Write(this, string, offset, length);
};
Buffer$2.prototype.slice = function slice(start, end) {
var len = this.length;
start = ~~start;
end = end === void 0 ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0)
start = 0;
} else if (start > len) {
start = len;
}
if (end < 0) {
end += len;
if (end < 0)
end = 0;
} else if (end > len) {
end = len;
}
if (end < start)
end = start;
var newBuf;
if (Buffer$2.TYPED_ARRAY_SUPPORT) {
newBuf = this.subarray(start, end);
newBuf.__proto__ = Buffer$2.prototype;
} else {
var sliceLen = end - start;
newBuf = new Buffer$2(sliceLen, void 0);
for (var i2 = 0; i2 < sliceLen; ++i2) {
newBuf[i2] = this[i2 + start];
}
}
return newBuf;
};
Buffer$2.prototype.copy = function copy(target, targetStart, start, end) {
if (!start)
start = 0;
if (!end && end !== 0)
end = this.length;
if (targetStart >= target.length)
targetStart = target.length;
if (!targetStart)
targetStart = 0;
if (end > 0 && end < start)
end = start;
if (end === start)
return 0;
if (target.length === 0 || this.length === 0)
return 0;
if (targetStart < 0) {
throw new RangeError("targetStart out of bounds");
}
if (start < 0 || start >= this.length)
throw new RangeError("sourceStart out of bounds");
if (end < 0)
throw new RangeError("sourceEnd out of bounds");
if (end > this.length)
end = this.length;
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start;
}
var len = end - start;
var i2;
if (this === target && start < targetStart && targetStart < end) {
for (i2 = len - 1; i2 >= 0; --i2) {
target[i2 + targetStart] = this[i2 + start];
}
} else if (len < 1e3 || !Buffer$2.TYPED_ARRAY_SUPPORT) {
for (i2 = 0; i2 < len; ++i2) {
target[i2 + targetStart] = this[i2 + start];
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, start + len),
targetStart
);
}
return len;
};
Buffer$2.prototype.fill = function fill(val, start, end) {
if (typeof val === "string") {
if (typeof start === "string") {
start = 0;
end = this.length;
} else if (typeof end === "string") {
end = this.length;
}
if (val.length === 1) {
var code = val.charCodeAt(0);
if (code < 256) {
val = code;
}
}
} else if (typeof val === "number") {
val = val & 255;
}
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError("Out of range index");
}
if (end <= start) {
return this;
}
start = start >>> 0;
end = end === void 0 ? this.length : end >>> 0;
if (!val)
val = 0;
var i2;
if (typeof val === "number") {
for (i2 = start; i2 < end; ++i2) {
this[i2] = val;
}
} else {
var bytes = Buffer$2.isBuffer(val) ? val : new Buffer$2(val);
var len = bytes.length;
for (i2 = 0; i2 < end - start; ++i2) {
this[i2 + start] = bytes[i2 % len];
}
}
return this;
};
Buffer$2.concat = function concat(list, length) {
if (!isArray$1(list)) {
throw new TypeError('"list" argument must be an Array of Buffers');
}
if (list.length === 0) {
return createBuffer(null, 0);
}
var i2;
if (length === void 0) {
length = 0;
for (i2 = 0; i2 < list.length; ++i2) {
length += list[i2].length;
}
}
var buffer2 = allocUnsafe(null, length);
var pos = 0;
for (i2 = 0; i2 < list.length; ++i2) {
var buf = list[i2];
if (!Buffer$2.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers');
}
buf.copy(buffer2, pos);
pos += buf.length;
}
return buffer2;
};
Buffer$2.byteLength = byteLength;
Buffer$2.prototype._isBuffer = true;
Buffer$2.isBuffer = function isBuffer(b2) {
return !!(b2 != null && b2._isBuffer);
};
typedarrayBuffer.alloc = function(size) {
var buffer2 = new Buffer$2(size);
buffer2.fill(0);
return buffer2;
};
typedarrayBuffer.from = function(data) {
return new Buffer$2(data);
};
var utils$1 = {};
var toSJISFunction;
var CODEWORDS_COUNT = [
0,
// Not used
26,
44,
70,
100,
134,
172,
196,
242,
292,
346,
404,
466,
532,
581,
655,
733,
815,
901,
991,
1085,
1156,
1258,
1364,
1474,
1588,
1706,
1828,
1921,
2051,
2185,
2323,
2465,
2611,
2761,
2876,
3034,
3196,
3362,
3532,
3706
];
utils$1.getSymbolSize = function getSymbolSize(version2) {
if (!version2)
throw new Error('"version" cannot be null or undefined');
if (version2 < 1 || version2 > 40)
throw new Error('"version" should be in range from 1 to 40');
return version2 * 4 + 17;
};
utils$1.getSymbolTotalCodewords = function getSymbolTotalCodewords(version2) {
return CODEWORDS_COUNT[version2];
};
utils$1.getBCHDigit = function(data) {
var digit = 0;
while (data !== 0) {
digit++;
data >>>= 1;
}
return digit;
};
utils$1.setToSJISFunction = function setToSJISFunction(f2) {
if (typeof f2 !== "function") {
throw new Error('"toSJISFunc" is not a valid function.');
}
toSJISFunction = f2;
};
utils$1.isKanjiModeEnabled = function() {
return typeof toSJISFunction !== "undefined";
};
utils$1.toSJIS = function toSJIS(kanji2) {
return toSJISFunction(kanji2);
};
var errorCorrectionLevel = {};
(function(exports) {
exports.L = { bit: 1 };
exports.M = { bit: 0 };
exports.Q = { bit: 3 };
exports.H = { bit: 2 };
function fromString2(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
var lcStr = string.toLowerCase();
switch (lcStr) {
case "l":
case "low":
return exports.L;
case "m":
case "medium":
return exports.M;
case "q":
case "quartile":
return exports.Q;
case "h":
case "high":
return exports.H;
default:
throw new Error("Unknown EC Level: " + string);
}
}
exports.isValid = function isValid2(level) {
return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
};
exports.from = function from2(value, defaultValue) {
if (exports.isValid(value)) {
return value;
}
try {
return fromString2(value);
} catch (e2) {
return defaultValue;
}
};
})(errorCorrectionLevel);
function BitBuffer$1() {
this.buffer = [];
this.length = 0;
}
BitBuffer$1.prototype = {
get: function(index2) {
var bufIndex = Math.floor(index2 / 8);
return (this.buffer[bufIndex] >>> 7 - index2 % 8 & 1) === 1;
},
put: function(num, length) {
for (var i2 = 0; i2 < length; i2++) {
this.putBit((num >>> length - i2 - 1 & 1) === 1);
}
},
getLengthInBits: function() {
return this.length;
},
putBit: function(bit) {
var bufIndex = Math.floor(this.length / 8);
if (this.buffer.length <= bufIndex) {
this.buffer.push(0);
}
if (bit) {
this.buffer[bufIndex] |= 128 >>> this.length % 8;
}
this.length++;
}
};
var bitBuffer = BitBuffer$1;
var BufferUtil$4 = typedarrayBuffer;
function BitMatrix$1(size) {
if (!size || size < 1) {
throw new Error("BitMatrix size must be defined and greater than 0");
}
this.size = size;
this.data = BufferUtil$4.alloc(size * size);
this.reservedBit = BufferUtil$4.alloc(size * size);
}
BitMatrix$1.prototype.set = function(row, col, value, reserved) {
var index2 = row * this.size + col;
this.data[index2] = value;
if (reserved)
this.reservedBit[index2] = true;
};
BitMatrix$1.prototype.get = function(row, col) {
return this.data[row * this.size + col];
};
BitMatrix$1.prototype.xor = function(row, col, value) {
this.data[row * this.size + col] ^= value;
};
BitMatrix$1.prototype.isReserved = function(row, col) {
return this.reservedBit[row * this.size + col];
};
var bitMatrix = BitMatrix$1;
var alignmentPattern = {};
(function(exports) {
var getSymbolSize3 = utils$1.getSymbolSize;
exports.getRowColCoords = function getRowColCoords(version2) {
if (version2 === 1)
return [];
var posCount = Math.floor(version2 / 7) + 2;
var size = getSymbolSize3(version2);
var intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
var positions = [size - 7];
for (var i2 = 1; i2 < posCount - 1; i2++) {
positions[i2] = positions[i2 - 1] - intervals;
}
positions.push(6);
return positions.reverse();
};
exports.getPositions = function getPositions2(version2) {
var coords = [];
var pos = exports.getRowColCoords(version2);
var posLength = pos.length;
for (var i2 = 0; i2 < posLength; i2++) {
for (var j2 = 0; j2 < posLength; j2++) {
if (i2 === 0 && j2 === 0 || // top-left
i2 === 0 && j2 === posLength - 1 || // bottom-left
i2 === posLength - 1 && j2 === 0) {
continue;
}
coords.push([pos[i2], pos[j2]]);
}
}
return coords;
};
})(alignmentPattern);
var finderPattern = {};
var getSymbolSize2 = utils$1.getSymbolSize;
var FINDER_PATTERN_SIZE = 7;
finderPattern.getPositions = function getPositions(version2) {
var size = getSymbolSize2(version2);
return [
// top-left
[0, 0],
// top-right
[size - FINDER_PATTERN_SIZE, 0],
// bottom-left
[0, size - FINDER_PATTERN_SIZE]
];
};
var maskPattern = {};
(function(exports) {
exports.Patterns = {
PATTERN000: 0,
PATTERN001: 1,
PATTERN010: 2,
PATTERN011: 3,
PATTERN100: 4,
PATTERN101: 5,
PATTERN110: 6,
PATTERN111: 7
};
var PenaltyScores = {
N1: 3,
N2: 3,
N3: 40,
N4: 10
};
exports.isValid = function isValid2(mask) {
return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
};
exports.from = function from2(value) {
return exports.isValid(value) ? parseInt(value, 10) : void 0;
};
exports.getPenaltyN1 = function getPenaltyN1(data) {
var size = data.size;
var points = 0;
var sameCountCol = 0;
var sameCountRow = 0;
var lastCol = null;
var lastRow = null;
for (var row = 0; row < size; row++) {
sameCountCol = sameCountRow = 0;
lastCol = lastRow = null;
for (var col = 0; col < size; col++) {
var module = data.get(row, col);
if (module === lastCol) {
sameCountCol++;
} else {
if (sameCountCol >= 5)
points += PenaltyScores.N1 + (sameCountCol - 5);
lastCol = module;
sameCountCol = 1;
}
module = data.get(col, row);
if (module === lastRow) {
sameCountRow++;
} else {
if (sameCountRow >= 5)
points += PenaltyScores.N1 + (sameCountRow - 5);
lastRow = module;
sameCountRow = 1;
}
}
if (sameCountCol >= 5)
points += PenaltyScores.N1 + (sameCountCol - 5);
if (sameCountRow >= 5)
points += PenaltyScores.N1 + (sameCountRow - 5);
}
return points;
};
exports.getPenaltyN2 = function getPenaltyN2(data) {
var size = data.size;
var points = 0;
for (var row = 0; row < size - 1; row++) {
for (var col = 0; col < size - 1; col++) {
var last = data.get(row, col) + data.get(row, col + 1) + data.get(row + 1, col) + data.get(row + 1, col + 1);
if (last === 4 || last === 0)
points++;
}
}
return points * PenaltyScores.N2;
};
exports.getPenaltyN3 = function getPenaltyN3(data) {
var size = data.size;
var points = 0;
var bitsCol = 0;
var bitsRow = 0;
for (var row = 0; row < size; row++) {
bitsCol = bitsRow = 0;
for (var col = 0; col < size; col++) {
bitsCol = bitsCol << 1 & 2047 | data.get(row, col);
if (col >= 10 && (bitsCol === 1488 || bitsCol === 93))
points++;
bitsRow = bitsRow << 1 & 2047 | data.get(col, row);
if (col >= 10 && (bitsRow === 1488 || bitsRow === 93))
points++;
}
}
return points * PenaltyScores.N3;
};
exports.getPenaltyN4 = function getPenaltyN4(data) {
var darkCount = 0;
var modulesCount = data.data.length;
for (var i2 = 0; i2 < modulesCount; i2++)
darkCount += data.data[i2];
var k2 = Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10);
return k2 * PenaltyScores.N4;
};
function getMaskAt(maskPattern2, i2, j2) {
switch (maskPattern2) {
case exports.Patterns.PATTERN000:
return (i2 + j2) % 2 === 0;
case exports.Patterns.PATTERN001:
return i2 % 2 === 0;
case exports.Patterns.PATTERN010:
return j2 % 3 === 0;
case exports.Patterns.PATTERN011:
return (i2 + j2) % 3 === 0;
case exports.Patterns.PATTERN100:
return (Math.floor(i2 / 2) + Math.floor(j2 / 3)) % 2 === 0;
case exports.Patterns.PATTERN101:
return i2 * j2 % 2 + i2 * j2 % 3 === 0;
case exports.Patterns.PATTERN110:
return (i2 * j2 % 2 + i2 * j2 % 3) % 2 === 0;
case exports.Patterns.PATTERN111:
return (i2 * j2 % 3 + (i2 + j2) % 2) % 2 === 0;
default:
throw new Error("bad maskPattern:" + maskPattern2);
}
}
exports.applyMask = function applyMask(pattern, data) {
var size = data.size;
for (var col = 0; col < size; col++) {
for (var row = 0; row < size; row++) {
if (data.isReserved(row, col))
continue;
data.xor(row, col, getMaskAt(pattern, row, col));
}
}
};
exports.getBestMask = function getBestMask(data, setupFormatFunc) {
var numPatterns = Object.keys(exports.Patterns).length;
var bestPattern = 0;
var lowerPenalty = Infinity;
for (var p2 = 0; p2 < numPatterns; p2++) {
setupFormatFunc(p2);
exports.applyMask(p2, data);
var penalty = exports.getPenaltyN1(data) + exports.getPenaltyN2(data) + exports.getPenaltyN3(data) + exports.getPenaltyN4(data);
exports.applyMask(p2, data);
if (penalty < lowerPenalty) {
lowerPenalty = penalty;
bestPattern = p2;
}
}
return bestPattern;
};
})(maskPattern);
var errorCorrectionCode = {};
var ECLevel$1 = errorCorrectionLevel;
var EC_BLOCKS_TABLE = [
// L M Q H
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
1,
2,
2,
4,
1,
2,
4,
4,
2,
4,
4,
4,
2,
4,
6,
5,
2,
4,
6,
6,
2,
5,
8,
8,
4,
5,
8,
8,
4,
5,
8,
11,
4,
8,
10,
11,
4,
9,
12,
16,
4,
9,
16,
16,
6,
10,
12,
18,
6,
10,
17,
16,
6,
11,
16,
19,
6,
13,
18,
21,
7,
14,
21,
25,
8,
16,
20,
25,
8,
17,
23,
25,
9,
17,
23,
34,
9,
18,
25,
30,
10,
20,
27,
32,
12,
21,
29,
35,
12,
23,
34,
37,
12,
25,
34,
40,
13,
26,
35,
42,
14,
28,
38,
45,
15,
29,
40,
48,
16,
31,
43,
51,
17,
33,
45,
54,
18,
35,
48,
57,
19,
37,
51,
60,
19,
38,
53,
63,
20,
40,
56,
66,
21,
43,
59,
70,
22,
45,
62,
74,
24,
47,
65,
77,
25,
49,
68,
81
];
var EC_CODEWORDS_TABLE = [
// L M Q H
7,
10,
13,
17,
10,
16,
22,
28,
15,
26,
36,
44,
20,
36,
52,
64,
26,
48,
72,
88,
36,
64,
96,
112,
40,
72,
108,
130,
48,
88,
132,
156,
60,
110,
160,
192,
72,
130,
192,
224,
80,
150,
224,
264,
96,
176,
260,
308,
104,
198,
288,
352,
120,
216,
320,
384,
132,
240,
360,
432,
144,
280,
408,
480,
168,
308,
448,
532,
180,
338,
504,
588,
196,
364,
546,
650,
224,
416,
600,
700,
224,
442,
644,
750,
252,
476,
690,
816,
270,
504,
750,
900,
300,
560,
810,
960,
312,
588,
870,
1050,
336,
644,
952,
1110,
360,
700,
1020,
1200,
390,
728,
1050,
1260,
420,
784,
1140,
1350,
450,
812,
1200,
1440,
480,
868,
1290,
1530,
510,
924,
1350,
1620,
540,
980,
1440,
1710,
570,
1036,
1530,
1800,
570,
1064,
1590,
1890,
600,
1120,
1680,
1980,
630,
1204,
1770,
2100,
660,
1260,
1860,
2220,
720,
1316,
1950,
2310,
750,
1372,
2040,
2430
];
errorCorrectionCode.getBlocksCount = function getBlocksCount(version2, errorCorrectionLevel2) {
switch (errorCorrectionLevel2) {
case ECLevel$1.L:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 0];
case ECLevel$1.M:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 1];
case ECLevel$1.Q:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 2];
case ECLevel$1.H:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 3];
default:
return void 0;
}
};
errorCorrectionCode.getTotalCodewordsCount = function getTotalCodewordsCount(version2, errorCorrectionLevel2) {
switch (errorCorrectionLevel2) {
case ECLevel$1.L:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 0];
case ECLevel$1.M:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 1];
case ECLevel$1.Q:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 2];
case ECLevel$1.H:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 3];
default:
return void 0;
}
};
var polynomial = {};
var galoisField = {};
var BufferUtil$3 = typedarrayBuffer;
var EXP_TABLE = BufferUtil$3.alloc(512);
var LOG_TABLE = BufferUtil$3.alloc(256);
(function initTables() {
var x2 = 1;
for (var i2 = 0; i2 < 255; i2++) {
EXP_TABLE[i2] = x2;
LOG_TABLE[x2] = i2;
x2 <<= 1;
if (x2 & 256) {
x2 ^= 285;
}
}
for (i2 = 255; i2 < 512; i2++) {
EXP_TABLE[i2] = EXP_TABLE[i2 - 255];
}
})();
galoisField.log = function log(n2) {
if (n2 < 1)
throw new Error("log(" + n2 + ")");
return LOG_TABLE[n2];
};
galoisField.exp = function exp(n2) {
return EXP_TABLE[n2];
};
galoisField.mul = function mul(x2, y2) {
if (x2 === 0 || y2 === 0)
return 0;
return EXP_TABLE[LOG_TABLE[x2] + LOG_TABLE[y2]];
};
(function(exports) {
var BufferUtil2 = typedarrayBuffer;
var GF = galoisField;
exports.mul = function mul2(p1, p2) {
var coeff = BufferUtil2.alloc(p1.length + p2.length - 1);
for (var i2 = 0; i2 < p1.length; i2++) {
for (var j2 = 0; j2 < p2.length; j2++) {
coeff[i2 + j2] ^= GF.mul(p1[i2], p2[j2]);
}
}
return coeff;
};
exports.mod = function mod(divident, divisor) {
var result = BufferUtil2.from(divident);
while (result.length - divisor.length >= 0) {
var coeff = result[0];
for (var i2 = 0; i2 < divisor.length; i2++) {
result[i2] ^= GF.mul(divisor[i2], coeff);
}
var offset = 0;
while (offset < result.length && result[offset] === 0)
offset++;
result = result.slice(offset);
}
return result;
};
exports.generateECPolynomial = function generateECPolynomial(degree) {
var poly = BufferUtil2.from([1]);
for (var i2 = 0; i2 < degree; i2++) {
poly = exports.mul(poly, [1, GF.exp(i2)]);
}
return poly;
};
})(polynomial);
var buffer = {};
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
(function(exports) {
var base64 = base64Js;
var ieee754$1 = ieee754;
var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
exports.Buffer = Buffer2;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
var K_MAX_LENGTH2 = 2147483647;
exports.kMaxLength = K_MAX_LENGTH2;
Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport2();
if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
console.error(
"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
);
}
function typedArraySupport2() {
try {
var arr = new Uint8Array(1);
var proto = { foo: function() {
return 42;
} };
Object.setPrototypeOf(proto, Uint8Array.prototype);
Object.setPrototypeOf(arr, proto);
return arr.foo() === 42;
} catch (e2) {
return false;
}
}
Object.defineProperty(Buffer2.prototype, "parent", {
enumerable: true,
get: function() {
if (!Buffer2.isBuffer(this))
return void 0;
return this.buffer;
}
});
Object.defineProperty(Buffer2.prototype, "offset", {
enumerable: true,
get: function() {
if (!Buffer2.isBuffer(this))
return void 0;
return this.byteOffset;
}
});
function createBuffer2(length) {
if (length > K_MAX_LENGTH2) {
throw new RangeError('The value "' + length + '" is invalid for option "size"');
}
var buf = new Uint8Array(length);
Object.setPrototypeOf(buf, Buffer2.prototype);
return buf;
}
function Buffer2(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string") {
throw new TypeError(
'The "string" argument must be of type string. Received type number'
);
}
return allocUnsafe2(arg);
}
return from2(arg, encodingOrOffset, length);
}
Buffer2.poolSize = 8192;
function from2(value, encodingOrOffset, length) {
if (typeof value === "string") {
return fromString2(value, encodingOrOffset);
}
if (ArrayBuffer.isView(value)) {
return fromArrayView(value);
}
if (value == null) {
throw new TypeError(
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
);
}
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
return fromArrayBuffer2(value, encodingOrOffset, length);
}
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
return fromArrayBuffer2(value, encodingOrOffset, length);
}
if (typeof value === "number") {
throw new TypeError(
'The "value" argument must not be of type number. Received type number'
);
}
var valueOf = value.valueOf && value.valueOf();
if (valueOf != null && valueOf !== value) {
return Buffer2.from(valueOf, encodingOrOffset, length);
}
var b2 = fromObject2(value);
if (b2)
return b2;
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
return Buffer2.from(
value[Symbol.toPrimitive]("string"),
encodingOrOffset,
length
);
}
throw new TypeError(
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
);
}
Buffer2.from = function(value, encodingOrOffset, length) {
return from2(value, encodingOrOffset, length);
};
Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
Object.setPrototypeOf(Buffer2, Uint8Array);
function assertSize(size) {
if (typeof size !== "number") {
throw new TypeError('"size" argument must be of type number');
} else if (size < 0) {
throw new RangeError('The value "' + size + '" is invalid for option "size"');
}
}
function alloc(size, fill2, encoding) {
assertSize(size);
if (size <= 0) {
return createBuffer2(size);
}
if (fill2 !== void 0) {
return typeof encoding === "string" ? createBuffer2(size).fill(fill2, encoding) : createBuffer2(size).fill(fill2);
}
return createBuffer2(size);
}
Buffer2.alloc = function(size, fill2, encoding) {
return alloc(size, fill2, encoding);
};
function allocUnsafe2(size) {
assertSize(size);
return createBuffer2(size < 0 ? 0 : checked2(size) | 0);
}
Buffer2.allocUnsafe = function(size) {
return allocUnsafe2(size);
};
Buffer2.allocUnsafeSlow = function(size) {
return allocUnsafe2(size);
};
function fromString2(string, encoding) {
if (typeof encoding !== "string" || encoding === "") {
encoding = "utf8";
}
if (!Buffer2.isEncoding(encoding)) {
throw new TypeError("Unknown encoding: " + encoding);
}
var length = byteLength2(string, encoding) | 0;
var buf = createBuffer2(length);
var actual = buf.write(string, encoding);
if (actual !== length) {
buf = buf.slice(0, actual);
}
return buf;
}
function fromArrayLike2(array) {
var length = array.length < 0 ? 0 : checked2(array.length) | 0;
var buf = createBuffer2(length);
for (var i2 = 0; i2 < length; i2 += 1) {
buf[i2] = array[i2] & 255;
}
return buf;
}
function fromArrayView(arrayView) {
if (isInstance(arrayView, Uint8Array)) {
var copy3 = new Uint8Array(arrayView);
return fromArrayBuffer2(copy3.buffer, copy3.byteOffset, copy3.byteLength);
}
return fromArrayLike2(arrayView);
}
function fromArrayBuffer2(array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('"offset" is outside of buffer bounds');
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('"length" is outside of buffer bounds');
}
var buf;
if (byteOffset === void 0 && length === void 0) {
buf = new Uint8Array(array);
} else if (length === void 0) {
buf = new Uint8Array(array, byteOffset);
} else {
buf = new Uint8Array(array, byteOffset, length);
}
Object.setPrototypeOf(buf, Buffer2.prototype);
return buf;
}
function fromObject2(obj) {
if (Buffer2.isBuffer(obj)) {
var len = checked2(obj.length) | 0;
var buf = createBuffer2(len);
if (buf.length === 0) {
return buf;
}
obj.copy(buf, 0, 0, len);
return buf;
}
if (obj.length !== void 0) {
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
return createBuffer2(0);
}
return fromArrayLike2(obj);
}
if (obj.type === "Buffer" && Array.isArray(obj.data)) {
return fromArrayLike2(obj.data);
}
}
function checked2(length) {
if (length >= K_MAX_LENGTH2) {
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH2.toString(16) + " bytes");
}
return length | 0;
}
function SlowBuffer(length) {
if (+length != length) {
length = 0;
}
return Buffer2.alloc(+length);
}
Buffer2.isBuffer = function isBuffer2(b2) {
return b2 != null && b2._isBuffer === true && b2 !== Buffer2.prototype;
};
Buffer2.compare = function compare(a2, b2) {
if (isInstance(a2, Uint8Array))
a2 = Buffer2.from(a2, a2.offset, a2.byteLength);
if (isInstance(b2, Uint8Array))
b2 = Buffer2.from(b2, b2.offset, b2.byteLength);
if (!Buffer2.isBuffer(a2) || !Buffer2.isBuffer(b2)) {
throw new TypeError(
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
);
}
if (a2 === b2)
return 0;
var x2 = a2.length;
var y2 = b2.length;
for (var i2 = 0, len = Math.min(x2, y2); i2 < len; ++i2) {
if (a2[i2] !== b2[i2]) {
x2 = a2[i2];
y2 = b2[i2];
break;
}
}
if (x2 < y2)
return -1;
if (y2 < x2)
return 1;
return 0;
};
Buffer2.isEncoding = function isEncoding(encoding) {
switch (String(encoding).toLowerCase()) {
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "latin1":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return true;
default:
return false;
}
};
Buffer2.concat = function concat2(list, length) {
if (!Array.isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers');
}
if (list.length === 0) {
return Buffer2.alloc(0);
}
var i2;
if (length === void 0) {
length = 0;
for (i2 = 0; i2 < list.length; ++i2) {
length += list[i2].length;
}
}
var buffer2 = Buffer2.allocUnsafe(length);
var pos = 0;
for (i2 = 0; i2 < list.length; ++i2) {
var buf = list[i2];
if (isInstance(buf, Uint8Array)) {
if (pos + buf.length > buffer2.length) {
Buffer2.from(buf).copy(buffer2, pos);
} else {
Uint8Array.prototype.set.call(
buffer2,
buf,
pos
);
}
} else if (!Buffer2.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers');
} else {
buf.copy(buffer2, pos);
}
pos += buf.length;
}
return buffer2;
};
function byteLength2(string, encoding) {
if (Buffer2.isBuffer(string)) {
return string.length;
}
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
return string.byteLength;
}
if (typeof string !== "string") {
throw new TypeError(
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
);
}
var len = string.length;
var mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len === 0)
return 0;
var loweredCase = false;
for (; ; ) {
switch (encoding) {
case "ascii":
case "latin1":
case "binary":
return len;
case "utf8":
case "utf-8":
return utf8ToBytes2(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return len * 2;
case "hex":
return len >>> 1;
case "base64":
return base64ToBytes(string).length;
default:
if (loweredCase) {
return mustMatch ? -1 : utf8ToBytes2(string).length;
}
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
}
Buffer2.byteLength = byteLength2;
function slowToString(encoding, start, end) {
var loweredCase = false;
if (start === void 0 || start < 0) {
start = 0;
}
if (start > this.length) {
return "";
}
if (end === void 0 || end > this.length) {
end = this.length;
}
if (end <= 0) {
return "";
}
end >>>= 0;
start >>>= 0;
if (end <= start) {
return "";
}
if (!encoding)
encoding = "utf8";
while (true) {
switch (encoding) {
case "hex":
return hexSlice(this, start, end);
case "utf8":
case "utf-8":
return utf8Slice(this, start, end);
case "ascii":
return asciiSlice(this, start, end);
case "latin1":
case "binary":
return latin1Slice(this, start, end);
case "base64":
return base64Slice(this, start, end);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return utf16leSlice(this, start, end);
default:
if (loweredCase)
throw new TypeError("Unknown encoding: " + encoding);
encoding = (encoding + "").toLowerCase();
loweredCase = true;
}
}
}
Buffer2.prototype._isBuffer = true;
function swap(b2, n2, m2) {
var i2 = b2[n2];
b2[n2] = b2[m2];
b2[m2] = i2;
}
Buffer2.prototype.swap16 = function swap16() {
var len = this.length;
if (len % 2 !== 0) {
throw new RangeError("Buffer size must be a multiple of 16-bits");
}
for (var i2 = 0; i2 < len; i2 += 2) {
swap(this, i2, i2 + 1);
}
return this;
};
Buffer2.prototype.swap32 = function swap32() {
var len = this.length;
if (len % 4 !== 0) {
throw new RangeError("Buffer size must be a multiple of 32-bits");
}
for (var i2 = 0; i2 < len; i2 += 4) {
swap(this, i2, i2 + 3);
swap(this, i2 + 1, i2 + 2);
}
return this;
};
Buffer2.prototype.swap64 = function swap64() {
var len = this.length;
if (len % 8 !== 0) {
throw new RangeError("Buffer size must be a multiple of 64-bits");
}
for (var i2 = 0; i2 < len; i2 += 8) {
swap(this, i2, i2 + 7);
swap(this, i2 + 1, i2 + 6);
swap(this, i2 + 2, i2 + 5);
swap(this, i2 + 3, i2 + 4);
}
return this;
};
Buffer2.prototype.toString = function toString2() {
var length = this.length;
if (length === 0)
return "";
if (arguments.length === 0)
return utf8Slice(this, 0, length);
return slowToString.apply(this, arguments);
};
Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
Buffer2.prototype.equals = function equals(b2) {
if (!Buffer2.isBuffer(b2))
throw new TypeError("Argument must be a Buffer");
if (this === b2)
return true;
return Buffer2.compare(this, b2) === 0;
};
Buffer2.prototype.inspect = function inspect() {
var str = "";
var max = exports.INSPECT_MAX_BYTES;
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
if (this.length > max)
str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol) {
Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
}
Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) {
target = Buffer2.from(target, target.offset, target.byteLength);
}
if (!Buffer2.isBuffer(target)) {
throw new TypeError(
'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
);
}
if (start === void 0) {
start = 0;
}
if (end === void 0) {
end = target ? target.length : 0;
}
if (thisStart === void 0) {
thisStart = 0;
}
if (thisEnd === void 0) {
thisEnd = this.length;
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError("out of range index");
}
if (thisStart >= thisEnd && start >= end) {
return 0;
}
if (thisStart >= thisEnd) {
return -1;
}
if (start >= end) {
return 1;
}
start >>>= 0;
end >>>= 0;
thisStart >>>= 0;
thisEnd >>>= 0;
if (this === target)
return 0;
var x2 = thisEnd - thisStart;
var y2 = end - start;
var len = Math.min(x2, y2);
var thisCopy = this.slice(thisStart, thisEnd);
var targetCopy = target.slice(start, end);
for (var i2 = 0; i2 < len; ++i2) {
if (thisCopy[i2] !== targetCopy[i2]) {
x2 = thisCopy[i2];
y2 = targetCopy[i2];
break;
}
}
if (x2 < y2)
return -1;
if (y2 < x2)
return 1;
return 0;
};
function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
if (buffer2.length === 0)
return -1;
if (typeof byteOffset === "string") {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 2147483647) {
byteOffset = 2147483647;
} else if (byteOffset < -2147483648) {
byteOffset = -2147483648;
}
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) {
byteOffset = dir ? 0 : buffer2.length - 1;
}
if (byteOffset < 0)
byteOffset = buffer2.length + byteOffset;
if (byteOffset >= buffer2.length) {
if (dir)
return -1;
else
byteOffset = buffer2.length - 1;
} else if (byteOffset < 0) {
if (dir)
byteOffset = 0;
else
return -1;
}
if (typeof val === "string") {
val = Buffer2.from(val, encoding);
}
if (Buffer2.isBuffer(val)) {
if (val.length === 0) {
return -1;
}
return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
} else if (typeof val === "number") {
val = val & 255;
if (typeof Uint8Array.prototype.indexOf === "function") {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
}
}
return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
}
throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
var indexSize = 1;
var arrLength = arr.length;
var valLength = val.length;
if (encoding !== void 0) {
encoding = String(encoding).toLowerCase();
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
if (arr.length < 2 || val.length < 2) {
return -1;
}
indexSize = 2;
arrLength /= 2;
valLength /= 2;
byteOffset /= 2;
}
}
function read(buf, i3) {
if (indexSize === 1) {
return buf[i3];
} else {
return buf.readUInt16BE(i3 * indexSize);
}
}
var i2;
if (dir) {
var foundIndex = -1;
for (i2 = byteOffset; i2 < arrLength; i2++) {
if (read(arr, i2) === read(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
if (foundIndex === -1)
foundIndex = i2;
if (i2 - foundIndex + 1 === valLength)
return foundIndex * indexSize;
} else {
if (foundIndex !== -1)
i2 -= i2 - foundIndex;
foundIndex = -1;
}
}
} else {
if (byteOffset + valLength > arrLength)
byteOffset = arrLength - valLength;
for (i2 = byteOffset; i2 >= 0; i2--) {
var found = true;
for (var j2 = 0; j2 < valLength; j2++) {
if (read(arr, i2 + j2) !== read(val, j2)) {
found = false;
break;
}
}
if (found)
return i2;
}
}
return -1;
}
Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
};
function hexWrite(buf, string, offset, length) {
offset = Number(offset) || 0;
var remaining = buf.length - offset;
if (!length) {
length = remaining;
} else {
length = Number(length);
if (length > remaining) {
length = remaining;
}
}
var strLen = string.length;
if (length > strLen / 2) {
length = strLen / 2;
}
for (var i2 = 0; i2 < length; ++i2) {
var parsed = parseInt(string.substr(i2 * 2, 2), 16);
if (numberIsNaN(parsed))
return i2;
buf[offset + i2] = parsed;
}
return i2;
}
function utf8Write2(buf, string, offset, length) {
return blitBuffer2(utf8ToBytes2(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
return blitBuffer2(asciiToBytes(string), buf, offset, length);
}
function base64Write(buf, string, offset, length) {
return blitBuffer2(base64ToBytes(string), buf, offset, length);
}
function ucs2Write(buf, string, offset, length) {
return blitBuffer2(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}
Buffer2.prototype.write = function write4(string, offset, length, encoding) {
if (offset === void 0) {
encoding = "utf8";
length = this.length;
offset = 0;
} else if (length === void 0 && typeof offset === "string") {
encoding = offset;
length = this.length;
offset = 0;
} else if (isFinite(offset)) {
offset = offset >>> 0;
if (isFinite(length)) {
length = length >>> 0;
if (encoding === void 0)
encoding = "utf8";
} else {
encoding = length;
length = void 0;
}
} else {
throw new Error(
"Buffer.write(string, encoding, offset[, length]) is no longer supported"
);
}
var remaining = this.length - offset;
if (length === void 0 || length > remaining)
length = remaining;
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
throw new RangeError("Attempt to write outside buffer bounds");
}
if (!encoding)
encoding = "utf8";
var loweredCase = false;
for (; ; ) {
switch (encoding) {
case "hex":
return hexWrite(this, string, offset, length);
case "utf8":
case "utf-8":
return utf8Write2(this, string, offset, length);
case "ascii":
case "latin1":
case "binary":
return asciiWrite(this, string, offset, length);
case "base64":
return base64Write(this, string, offset, length);
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return ucs2Write(this, string, offset, length);
default:
if (loweredCase)
throw new TypeError("Unknown encoding: " + encoding);
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
};
Buffer2.prototype.toJSON = function toJSON() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf);
} else {
return base64.fromByteArray(buf.slice(start, end));
}
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
var res = [];
var i2 = start;
while (i2 < end) {
var firstByte = buf[i2];
var codePoint = null;
var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i2 + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128) {
codePoint = firstByte;
}
break;
case 2:
secondByte = buf[i2 + 1];
if ((secondByte & 192) === 128) {
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
if (tempCodePoint > 127) {
codePoint = tempCodePoint;
}
}
break;
case 3:
secondByte = buf[i2 + 1];
thirdByte = buf[i2 + 2];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
codePoint = tempCodePoint;
}
}
break;
case 4:
secondByte = buf[i2 + 1];
thirdByte = buf[i2 + 2];
fourthByte = buf[i2 + 3];
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
codePoint = tempCodePoint;
}
}
}
}
if (codePoint === null) {
codePoint = 65533;
bytesPerSequence = 1;
} else if (codePoint > 65535) {
codePoint -= 65536;
res.push(codePoint >>> 10 & 1023 | 55296);
codePoint = 56320 | codePoint & 1023;
}
res.push(codePoint);
i2 += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
var MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
var len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints);
}
var res = "";
var i2 = 0;
while (i2 < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH)
);
}
return res;
}
function asciiSlice(buf, start, end) {
var ret = "";
end = Math.min(buf.length, end);
for (var i2 = start; i2 < end; ++i2) {
ret += String.fromCharCode(buf[i2] & 127);
}
return ret;
}
function latin1Slice(buf, start, end) {
var ret = "";
end = Math.min(buf.length, end);
for (var i2 = start; i2 < end; ++i2) {
ret += String.fromCharCode(buf[i2]);
}
return ret;
}
function hexSlice(buf, start, end) {
var len = buf.length;
if (!start || start < 0)
start = 0;
if (!end || end < 0 || end > len)
end = len;
var out = "";
for (var i2 = start; i2 < end; ++i2) {
out += hexSliceLookupTable[buf[i2]];
}
return out;
}
function utf16leSlice(buf, start, end) {
var bytes = buf.slice(start, end);
var res = "";
for (var i2 = 0; i2 < bytes.length - 1; i2 += 2) {
res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
}
return res;
}
Buffer2.prototype.slice = function slice2(start, end) {
var len = this.length;
start = ~~start;
end = end === void 0 ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0)
start = 0;
} else if (start > len) {
start = len;
}
if (end < 0) {
end += len;
if (end < 0)
end = 0;
} else if (end > len) {
end = len;
}
if (end < start)
end = start;
var newBuf = this.subarray(start, end);
Object.setPrototypeOf(newBuf, Buffer2.prototype);
return newBuf;
};
function checkOffset(offset, ext, length) {
if (offset % 1 !== 0 || offset < 0)
throw new RangeError("offset is not uint");
if (offset + ext > length)
throw new RangeError("Trying to access beyond buffer length");
}
Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert)
checkOffset(offset, byteLength3, this.length);
var val = this[offset];
var mul2 = 1;
var i2 = 0;
while (++i2 < byteLength3 && (mul2 *= 256)) {
val += this[offset + i2] * mul2;
}
return val;
};
Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
checkOffset(offset, byteLength3, this.length);
}
var val = this[offset + --byteLength3];
var mul2 = 1;
while (byteLength3 > 0 && (mul2 *= 256)) {
val += this[offset + --byteLength3] * mul2;
}
return val;
};
Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
};
Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert)
checkOffset(offset, byteLength3, this.length);
var val = this[offset];
var mul2 = 1;
var i2 = 0;
while (++i2 < byteLength3 && (mul2 *= 256)) {
val += this[offset + i2] * mul2;
}
mul2 *= 128;
if (val >= mul2)
val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert)
checkOffset(offset, byteLength3, this.length);
var i2 = byteLength3;
var mul2 = 1;
var val = this[offset + --i2];
while (i2 > 0 && (mul2 *= 256)) {
val += this[offset + --i2] * mul2;
}
mul2 *= 128;
if (val >= mul2)
val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 1, this.length);
if (!(this[offset] & 128))
return this[offset];
return (255 - this[offset] + 1) * -1;
};
Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 2, this.length);
var val = this[offset] | this[offset + 1] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 2, this.length);
var val = this[offset + 1] | this[offset] << 8;
return val & 32768 ? val | 4294901760 : val;
};
Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
};
Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
};
Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return ieee754$1.read(this, offset, true, 23, 4);
};
Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return ieee754$1.read(this, offset, false, 23, 4);
};
Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 8, this.length);
return ieee754$1.read(this, offset, true, 52, 8);
};
Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 8, this.length);
return ieee754$1.read(this, offset, false, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer2.isBuffer(buf))
throw new TypeError('"buffer" argument must be a Buffer instance');
if (value > max || value < min)
throw new RangeError('"value" argument is out of bounds');
if (offset + ext > buf.length)
throw new RangeError("Index out of range");
}
Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
checkInt(this, value, offset, byteLength3, maxBytes, 0);
}
var mul2 = 1;
var i2 = 0;
this[offset] = value & 255;
while (++i2 < byteLength3 && (mul2 *= 256)) {
this[offset + i2] = value / mul2 & 255;
}
return offset + byteLength3;
};
Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
checkInt(this, value, offset, byteLength3, maxBytes, 0);
}
var i2 = byteLength3 - 1;
var mul2 = 1;
this[offset + i2] = value & 255;
while (--i2 >= 0 && (mul2 *= 256)) {
this[offset + i2] = value / mul2 & 255;
}
return offset + byteLength3;
};
Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 1, 255, 0);
this[offset] = value & 255;
return offset + 1;
};
Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 4, 4294967295, 0);
this[offset + 3] = value >>> 24;
this[offset + 2] = value >>> 16;
this[offset + 1] = value >>> 8;
this[offset] = value & 255;
return offset + 4;
};
Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength3 - 1);
checkInt(this, value, offset, byteLength3, limit - 1, -limit);
}
var i2 = 0;
var mul2 = 1;
var sub = 0;
this[offset] = value & 255;
while (++i2 < byteLength3 && (mul2 *= 256)) {
if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0) {
sub = 1;
}
this[offset + i2] = (value / mul2 >> 0) - sub & 255;
}
return offset + byteLength3;
};
Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength3 - 1);
checkInt(this, value, offset, byteLength3, limit - 1, -limit);
}
var i2 = byteLength3 - 1;
var mul2 = 1;
var sub = 0;
this[offset + i2] = value & 255;
while (--i2 >= 0 && (mul2 *= 256)) {
if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0) {
sub = 1;
}
this[offset + i2] = (value / mul2 >> 0) - sub & 255;
}
return offset + byteLength3;
};
Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 1, 127, -128);
if (value < 0)
value = 255 + value + 1;
this[offset] = value & 255;
return offset + 1;
};
Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 4, 2147483647, -2147483648);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;
return offset + 4;
};
Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 4, 2147483647, -2147483648);
if (value < 0)
value = 4294967295 + value + 1;
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function checkIEEE754(buf, value, offset, ext, max, min) {
if (offset + ext > buf.length)
throw new RangeError("Index out of range");
if (offset < 0)
throw new RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
checkIEEE754(buf, value, offset, 4);
}
ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
return offset + 4;
}
Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert);
};
Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert);
};
function writeDouble(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
checkIEEE754(buf, value, offset, 8);
}
ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
return offset + 8;
}
Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert);
};
Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert);
};
Buffer2.prototype.copy = function copy3(target, targetStart, start, end) {
if (!Buffer2.isBuffer(target))
throw new TypeError("argument should be a Buffer");
if (!start)
start = 0;
if (!end && end !== 0)
end = this.length;
if (targetStart >= target.length)
targetStart = target.length;
if (!targetStart)
targetStart = 0;
if (end > 0 && end < start)
end = start;
if (end === start)
return 0;
if (target.length === 0 || this.length === 0)
return 0;
if (targetStart < 0) {
throw new RangeError("targetStart out of bounds");
}
if (start < 0 || start >= this.length)
throw new RangeError("Index out of range");
if (end < 0)
throw new RangeError("sourceEnd out of bounds");
if (end > this.length)
end = this.length;
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start;
}
var len = end - start;
if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
this.copyWithin(targetStart, start, end);
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, end),
targetStart
);
}
return len;
};
Buffer2.prototype.fill = function fill2(val, start, end, encoding) {
if (typeof val === "string") {
if (typeof start === "string") {
encoding = start;
start = 0;
end = this.length;
} else if (typeof end === "string") {
encoding = end;
end = this.length;
}
if (encoding !== void 0 && typeof encoding !== "string") {
throw new TypeError("encoding must be a string");
}
if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
throw new TypeError("Unknown encoding: " + encoding);
}
if (val.length === 1) {
var code = val.charCodeAt(0);
if (encoding === "utf8" && code < 128 || encoding === "latin1") {
val = code;
}
}
} else if (typeof val === "number") {
val = val & 255;
} else if (typeof val === "boolean") {
val = Number(val);
}
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError("Out of range index");
}
if (end <= start) {
return this;
}
start = start >>> 0;
end = end === void 0 ? this.length : end >>> 0;
if (!val)
val = 0;
var i2;
if (typeof val === "number") {
for (i2 = start; i2 < end; ++i2) {
this[i2] = val;
}
} else {
var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
var len = bytes.length;
if (len === 0) {
throw new TypeError('The value "' + val + '" is invalid for argument "value"');
}
for (i2 = 0; i2 < end - start; ++i2) {
this[i2 + start] = bytes[i2 % len];
}
}
return this;
};
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
str = str.split("=")[0];
str = str.trim().replace(INVALID_BASE64_RE, "");
if (str.length < 2)
return "";
while (str.length % 4 !== 0) {
str = str + "=";
}
return str;
}
function utf8ToBytes2(string, units) {
units = units || Infinity;
var codePoint;
var length = string.length;
var leadSurrogate = null;
var bytes = [];
for (var i2 = 0; i2 < length; ++i2) {
codePoint = string.charCodeAt(i2);
if (codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
} else if (i2 + 1 === length) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else if (leadSurrogate) {
if ((units -= 3) > -1)
bytes.push(239, 191, 189);
}
leadSurrogate = null;
if (codePoint < 128) {
if ((units -= 1) < 0)
break;
bytes.push(codePoint);
} else if (codePoint < 2048) {
if ((units -= 2) < 0)
break;
bytes.push(
codePoint >> 6 | 192,
codePoint & 63 | 128
);
} else if (codePoint < 65536) {
if ((units -= 3) < 0)
break;
bytes.push(
codePoint >> 12 | 224,
codePoint >> 6 & 63 | 128,
codePoint & 63 | 128
);
} else if (codePoint < 1114112) {
if ((units -= 4) < 0)
break;
bytes.push(
codePoint >> 18 | 240,
codePoint >> 12 & 63 | 128,
codePoint >> 6 & 63 | 128,
codePoint & 63 | 128
);
} else {
throw new Error("Invalid code point");
}
}
return bytes;
}
function asciiToBytes(str) {
var byteArray = [];
for (var i2 = 0; i2 < str.length; ++i2) {
byteArray.push(str.charCodeAt(i2) & 255);
}
return byteArray;
}
function utf16leToBytes(str, units) {
var c2, hi, lo;
var byteArray = [];
for (var i2 = 0; i2 < str.length; ++i2) {
if ((units -= 2) < 0)
break;
c2 = str.charCodeAt(i2);
hi = c2 >> 8;
lo = c2 % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer2(src, dst, offset, length) {
for (var i2 = 0; i2 < length; ++i2) {
if (i2 + offset >= dst.length || i2 >= src.length)
break;
dst[i2 + offset] = src[i2];
}
return i2;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
var hexSliceLookupTable = function() {
var alphabet = "0123456789abcdef";
var table = new Array(256);
for (var i2 = 0; i2 < 16; ++i2) {
var i16 = i2 * 16;
for (var j2 = 0; j2 < 16; ++j2) {
table[i16 + j2] = alphabet[i2] + alphabet[j2];
}
}
return table;
}();
})(buffer);
var BufferUtil$2 = typedarrayBuffer;
var Polynomial = polynomial;
var Buffer$1 = buffer.Buffer;
function ReedSolomonEncoder$1(degree) {
this.genPoly = void 0;
this.degree = degree;
if (this.degree)
this.initialize(this.degree);
}
ReedSolomonEncoder$1.prototype.initialize = function initialize(degree) {
this.degree = degree;
this.genPoly = Polynomial.generateECPolynomial(this.degree);
};
ReedSolomonEncoder$1.prototype.encode = function encode(data) {
if (!this.genPoly) {
throw new Error("Encoder not initialized");
}
var pad = BufferUtil$2.alloc(this.degree);
var paddedData = Buffer$1.concat([data, pad], data.length + this.degree);
var remainder = Polynomial.mod(paddedData, this.genPoly);
var start = this.degree - remainder.length;
if (start > 0) {
var buff = BufferUtil$2.alloc(this.degree);
remainder.copy(buff, start);
return buff;
}
return remainder;
};
var reedSolomonEncoder = ReedSolomonEncoder$1;
var version = {};
var mode = {};
var versionCheck = {};
versionCheck.isValid = function isValid(version2) {
return !isNaN(version2) && version2 >= 1 && version2 <= 40;
};
var regex = {};
var numeric = "[0-9]+";
var alphanumeric = "[A-Z $%*+\\-./:]+";
var kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
kanji = kanji.replace(/u/g, "\\u");
var byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
regex.KANJI = new RegExp(kanji, "g");
regex.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
regex.BYTE = new RegExp(byte, "g");
regex.NUMERIC = new RegExp(numeric, "g");
regex.ALPHANUMERIC = new RegExp(alphanumeric, "g");
var TEST_KANJI = new RegExp("^" + kanji + "$");
var TEST_NUMERIC = new RegExp("^" + numeric + "$");
var TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
regex.testKanji = function testKanji(str) {
return TEST_KANJI.test(str);
};
regex.testNumeric = function testNumeric(str) {
return TEST_NUMERIC.test(str);
};
regex.testAlphanumeric = function testAlphanumeric(str) {
return TEST_ALPHANUMERIC.test(str);
};
(function(exports) {
var VersionCheck = versionCheck;
var Regex = regex;
exports.NUMERIC = {
id: "Numeric",
bit: 1 << 0,
ccBits: [10, 12, 14]
};
exports.ALPHANUMERIC = {
id: "Alphanumeric",
bit: 1 << 1,
ccBits: [9, 11, 13]
};
exports.BYTE = {
id: "Byte",
bit: 1 << 2,
ccBits: [8, 16, 16]
};
exports.KANJI = {
id: "Kanji",
bit: 1 << 3,
ccBits: [8, 10, 12]
};
exports.MIXED = {
bit: -1
};
exports.getCharCountIndicator = function getCharCountIndicator(mode2, version2) {
if (!mode2.ccBits)
throw new Error("Invalid mode: " + mode2);
if (!VersionCheck.isValid(version2)) {
throw new Error("Invalid version: " + version2);
}
if (version2 >= 1 && version2 < 10)
return mode2.ccBits[0];
else if (version2 < 27)
return mode2.ccBits[1];
return mode2.ccBits[2];
};
exports.getBestModeForData = function getBestModeForData(dataStr) {
if (Regex.testNumeric(dataStr))
return exports.NUMERIC;
else if (Regex.testAlphanumeric(dataStr))
return exports.ALPHANUMERIC;
else if (Regex.testKanji(dataStr))
return exports.KANJI;
else
return exports.BYTE;
};
exports.toString = function toString2(mode2) {
if (mode2 && mode2.id)
return mode2.id;
throw new Error("Invalid mode");
};
exports.isValid = function isValid2(mode2) {
return mode2 && mode2.bit && mode2.ccBits;
};
function fromString2(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
var lcStr = string.toLowerCase();
switch (lcStr) {
case "numeric":
return exports.NUMERIC;
case "alphanumeric":
return exports.ALPHANUMERIC;
case "kanji":
return exports.KANJI;
case "byte":
return exports.BYTE;
default:
throw new Error("Unknown mode: " + string);
}
}
exports.from = function from2(value, defaultValue) {
if (exports.isValid(value)) {
return value;
}
try {
return fromString2(value);
} catch (e2) {
return defaultValue;
}
};
})(mode);
(function(exports) {
var Utils2 = utils$1;
var ECCode2 = errorCorrectionCode;
var ECLevel2 = errorCorrectionLevel;
var Mode2 = mode;
var VersionCheck = versionCheck;
var isArray2 = isarray;
var G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
var G18_BCH = Utils2.getBCHDigit(G18);
function getBestVersionForDataLength(mode2, length, errorCorrectionLevel2) {
for (var currentVersion = 1; currentVersion <= 40; currentVersion++) {
if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, mode2)) {
return currentVersion;
}
}
return void 0;
}
function getReservedBitsCount(mode2, version2) {
return Mode2.getCharCountIndicator(mode2, version2) + 4;
}
function getTotalBitsFromDataArray(segments2, version2) {
var totalBits = 0;
segments2.forEach(function(data) {
var reservedBits = getReservedBitsCount(data.mode, version2);
totalBits += reservedBits + data.getBitsLength();
});
return totalBits;
}
function getBestVersionForMixedData(segments2, errorCorrectionLevel2) {
for (var currentVersion = 1; currentVersion <= 40; currentVersion++) {
var length = getTotalBitsFromDataArray(segments2, currentVersion);
if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, Mode2.MIXED)) {
return currentVersion;
}
}
return void 0;
}
exports.from = function from2(value, defaultValue) {
if (VersionCheck.isValid(value)) {
return parseInt(value, 10);
}
return defaultValue;
};
exports.getCapacity = function getCapacity(version2, errorCorrectionLevel2, mode2) {
if (!VersionCheck.isValid(version2)) {
throw new Error("Invalid QR Code version");
}
if (typeof mode2 === "undefined")
mode2 = Mode2.BYTE;
var totalCodewords = Utils2.getSymbolTotalCodewords(version2);
var ecTotalCodewords = ECCode2.getTotalCodewordsCount(version2, errorCorrectionLevel2);
var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (mode2 === Mode2.MIXED)
return dataTotalCodewordsBits;
var usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode2, version2);
switch (mode2) {
case Mode2.NUMERIC:
return Math.floor(usableBits / 10 * 3);
case Mode2.ALPHANUMERIC:
return Math.floor(usableBits / 11 * 2);
case Mode2.KANJI:
return Math.floor(usableBits / 13);
case Mode2.BYTE:
default:
return Math.floor(usableBits / 8);
}
};
exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel2) {
var seg;
var ecl = ECLevel2.from(errorCorrectionLevel2, ECLevel2.M);
if (isArray2(data)) {
if (data.length > 1) {
return getBestVersionForMixedData(data, ecl);
}
if (data.length === 0) {
return 1;
}
seg = data[0];
} else {
seg = data;
}
return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
};
exports.getEncodedBits = function getEncodedBits2(version2) {
if (!VersionCheck.isValid(version2) || version2 < 7) {
throw new Error("Invalid QR Code version");
}
var d2 = version2 << 12;
while (Utils2.getBCHDigit(d2) - G18_BCH >= 0) {
d2 ^= G18 << Utils2.getBCHDigit(d2) - G18_BCH;
}
return version2 << 12 | d2;
};
})(version);
var formatInfo = {};
var Utils$3 = utils$1;
var G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
var G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
var G15_BCH = Utils$3.getBCHDigit(G15);
formatInfo.getEncodedBits = function getEncodedBits(errorCorrectionLevel2, mask) {
var data = errorCorrectionLevel2.bit << 3 | mask;
var d2 = data << 10;
while (Utils$3.getBCHDigit(d2) - G15_BCH >= 0) {
d2 ^= G15 << Utils$3.getBCHDigit(d2) - G15_BCH;
}
return (data << 10 | d2) ^ G15_MASK;
};
var segments = {};
var Mode$4 = mode;
function NumericData(data) {
this.mode = Mode$4.NUMERIC;
this.data = data.toString();
}
NumericData.getBitsLength = function getBitsLength(length) {
return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
};
NumericData.prototype.getLength = function getLength() {
return this.data.length;
};
NumericData.prototype.getBitsLength = function getBitsLength2() {
return NumericData.getBitsLength(this.data.length);
};
NumericData.prototype.write = function write2(bitBuffer2) {
var i2, group, value;
for (i2 = 0; i2 + 3 <= this.data.length; i2 += 3) {
group = this.data.substr(i2, 3);
value = parseInt(group, 10);
bitBuffer2.put(value, 10);
}
var remainingNum = this.data.length - i2;
if (remainingNum > 0) {
group = this.data.substr(i2);
value = parseInt(group, 10);
bitBuffer2.put(value, remainingNum * 3 + 1);
}
};
var numericData = NumericData;
var Mode$3 = mode;
var ALPHA_NUM_CHARS = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
" ",
"$",
"%",
"*",
"+",
"-",
".",
"/",
":"
];
function AlphanumericData(data) {
this.mode = Mode$3.ALPHANUMERIC;
this.data = data;
}
AlphanumericData.getBitsLength = function getBitsLength3(length) {
return 11 * Math.floor(length / 2) + 6 * (length % 2);
};
AlphanumericData.prototype.getLength = function getLength2() {
return this.data.length;
};
AlphanumericData.prototype.getBitsLength = function getBitsLength4() {
return AlphanumericData.getBitsLength(this.data.length);
};
AlphanumericData.prototype.write = function write3(bitBuffer2) {
var i2;
for (i2 = 0; i2 + 2 <= this.data.length; i2 += 2) {
var value = ALPHA_NUM_CHARS.indexOf(this.data[i2]) * 45;
value += ALPHA_NUM_CHARS.indexOf(this.data[i2 + 1]);
bitBuffer2.put(value, 11);
}
if (this.data.length % 2) {
bitBuffer2.put(ALPHA_NUM_CHARS.indexOf(this.data[i2]), 6);
}
};
var alphanumericData = AlphanumericData;
var BufferUtil$1 = typedarrayBuffer;
var Mode$2 = mode;
function ByteData(data) {
this.mode = Mode$2.BYTE;
this.data = BufferUtil$1.from(data);
}
ByteData.getBitsLength = function getBitsLength5(length) {
return length * 8;
};
ByteData.prototype.getLength = function getLength3() {
return this.data.length;
};
ByteData.prototype.getBitsLength = function getBitsLength6() {
return ByteData.getBitsLength(this.data.length);
};
ByteData.prototype.write = function(bitBuffer2) {
for (var i2 = 0, l2 = this.data.length; i2 < l2; i2++) {
bitBuffer2.put(this.data[i2], 8);
}
};
var byteData = ByteData;
var Mode$1 = mode;
var Utils$2 = utils$1;
function KanjiData(data) {
this.mode = Mode$1.KANJI;
this.data = data;
}
KanjiData.getBitsLength = function getBitsLength7(length) {
return length * 13;
};
KanjiData.prototype.getLength = function getLength4() {
return this.data.length;
};
KanjiData.prototype.getBitsLength = function getBitsLength8() {
return KanjiData.getBitsLength(this.data.length);
};
KanjiData.prototype.write = function(bitBuffer2) {
var i2;
for (i2 = 0; i2 < this.data.length; i2++) {
var value = Utils$2.toSJIS(this.data[i2]);
if (value >= 33088 && value <= 40956) {
value -= 33088;
} else if (value >= 57408 && value <= 60351) {
value -= 49472;
} else {
throw new Error(
"Invalid SJIS character: " + this.data[i2] + "\nMake sure your charset is UTF-8"
);
}
value = (value >>> 8 & 255) * 192 + (value & 255);
bitBuffer2.put(value, 13);
}
};
var kanjiData = KanjiData;
(function(exports) {
var Mode2 = mode;
var NumericData2 = numericData;
var AlphanumericData2 = alphanumericData;
var ByteData2 = byteData;
var KanjiData2 = kanjiData;
var Regex = regex;
var Utils2 = utils$1;
var dijkstra = dijkstraExports;
function getStringByteLength(str) {
return unescape(encodeURIComponent(str)).length;
}
function getSegments(regex2, mode2, str) {
var segments2 = [];
var result;
while ((result = regex2.exec(str)) !== null) {
segments2.push({
data: result[0],
index: result.index,
mode: mode2,
length: result[0].length
});
}
return segments2;
}
function getSegmentsFromString(dataStr) {
var numSegs = getSegments(Regex.NUMERIC, Mode2.NUMERIC, dataStr);
var alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode2.ALPHANUMERIC, dataStr);
var byteSegs;
var kanjiSegs;
if (Utils2.isKanjiModeEnabled()) {
byteSegs = getSegments(Regex.BYTE, Mode2.BYTE, dataStr);
kanjiSegs = getSegments(Regex.KANJI, Mode2.KANJI, dataStr);
} else {
byteSegs = getSegments(Regex.BYTE_KANJI, Mode2.BYTE, dataStr);
kanjiSegs = [];
}
var segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
return segs.sort(function(s1, s2) {
return s1.index - s2.index;
}).map(function(obj) {
return {
data: obj.data,
mode: obj.mode,
length: obj.length
};
});
}
function getSegmentBitsLength(length, mode2) {
switch (mode2) {
case Mode2.NUMERIC:
return NumericData2.getBitsLength(length);
case Mode2.ALPHANUMERIC:
return AlphanumericData2.getBitsLength(length);
case Mode2.KANJI:
return KanjiData2.getBitsLength(length);
case Mode2.BYTE:
return ByteData2.getBitsLength(length);
}
}
function mergeSegments(segs) {
return segs.reduce(function(acc, curr) {
var prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
if (prevSeg && prevSeg.mode === curr.mode) {
acc[acc.length - 1].data += curr.data;
return acc;
}
acc.push(curr);
return acc;
}, []);
}
function buildNodes(segs) {
var nodes = [];
for (var i2 = 0; i2 < segs.length; i2++) {
var seg = segs[i2];
switch (seg.mode) {
case Mode2.NUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.ALPHANUMERIC, length: seg.length },
{ data: seg.data, mode: Mode2.BYTE, length: seg.length }
]);
break;
case Mode2.ALPHANUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.BYTE, length: seg.length }
]);
break;
case Mode2.KANJI:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
]);
break;
case Mode2.BYTE:
nodes.push([
{ data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
]);
}
}
return nodes;
}
function buildGraph(nodes, version2) {
var table = {};
var graph = { "start": {} };
var prevNodeIds = ["start"];
for (var i2 = 0; i2 < nodes.length; i2++) {
var nodeGroup = nodes[i2];
var currentNodeIds = [];
for (var j2 = 0; j2 < nodeGroup.length; j2++) {
var node = nodeGroup[j2];
var key = "" + i2 + j2;
currentNodeIds.push(key);
table[key] = { node, lastCount: 0 };
graph[key] = {};
for (var n2 = 0; n2 < prevNodeIds.length; n2++) {
var prevNodeId = prevNodeIds[n2];
if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
graph[prevNodeId][key] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
table[prevNodeId].lastCount += node.length;
} else {
if (table[prevNodeId])
table[prevNodeId].lastCount = node.length;
graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode2.getCharCountIndicator(node.mode, version2);
}
}
}
prevNodeIds = currentNodeIds;
}
for (n2 = 0; n2 < prevNodeIds.length; n2++) {
graph[prevNodeIds[n2]]["end"] = 0;
}
return { map: graph, table };
}
function buildSingleSegment(data, modesHint) {
var mode2;
var bestMode = Mode2.getBestModeForData(data);
mode2 = Mode2.from(modesHint, bestMode);
if (mode2 !== Mode2.BYTE && mode2.bit < bestMode.bit) {
throw new Error('"' + data + '" cannot be encoded with mode ' + Mode2.toString(mode2) + ".\n Suggested mode is: " + Mode2.toString(bestMode));
}
if (mode2 === Mode2.KANJI && !Utils2.isKanjiModeEnabled()) {
mode2 = Mode2.BYTE;
}
switch (mode2) {
case Mode2.NUMERIC:
return new NumericData2(data);
case Mode2.ALPHANUMERIC:
return new AlphanumericData2(data);
case Mode2.KANJI:
return new KanjiData2(data);
case Mode2.BYTE:
return new ByteData2(data);
}
}
exports.fromArray = function fromArray(array) {
return array.reduce(function(acc, seg) {
if (typeof seg === "string") {
acc.push(buildSingleSegment(seg, null));
} else if (seg.data) {
acc.push(buildSingleSegment(seg.data, seg.mode));
}
return acc;
}, []);
};
exports.fromString = function fromString2(data, version2) {
var segs = getSegmentsFromString(data, Utils2.isKanjiModeEnabled());
var nodes = buildNodes(segs);
var graph = buildGraph(nodes, version2);
var path = dijkstra.find_path(graph.map, "start", "end");
var optimizedSegs = [];
for (var i2 = 1; i2 < path.length - 1; i2++) {
optimizedSegs.push(graph.table[path[i2]].node);
}
return exports.fromArray(mergeSegments(optimizedSegs));
};
exports.rawSplit = function rawSplit(data) {
return exports.fromArray(
getSegmentsFromString(data, Utils2.isKanjiModeEnabled())
);
};
})(segments);
var BufferUtil = typedarrayBuffer;
var Utils$1 = utils$1;
var ECLevel = errorCorrectionLevel;
var BitBuffer = bitBuffer;
var BitMatrix = bitMatrix;
var AlignmentPattern = alignmentPattern;
var FinderPattern = finderPattern;
var MaskPattern = maskPattern;
var ECCode = errorCorrectionCode;
var ReedSolomonEncoder = reedSolomonEncoder;
var Version = version;
var FormatInfo = formatInfo;
var Mode = mode;
var Segments = segments;
var isArray = isarray;
function setupFinderPattern(matrix, version2) {
var size = matrix.size;
var pos = FinderPattern.getPositions(version2);
for (var i2 = 0; i2 < pos.length; i2++) {
var row = pos[i2][0];
var col = pos[i2][1];
for (var r2 = -1; r2 <= 7; r2++) {
if (row + r2 <= -1 || size <= row + r2)
continue;
for (var c2 = -1; c2 <= 7; c2++) {
if (col + c2 <= -1 || size <= col + c2)
continue;
if (r2 >= 0 && r2 <= 6 && (c2 === 0 || c2 === 6) || c2 >= 0 && c2 <= 6 && (r2 === 0 || r2 === 6) || r2 >= 2 && r2 <= 4 && c2 >= 2 && c2 <= 4) {
matrix.set(row + r2, col + c2, true, true);
} else {
matrix.set(row + r2, col + c2, false, true);
}
}
}
}
}
function setupTimingPattern(matrix) {
var size = matrix.size;
for (var r2 = 8; r2 < size - 8; r2++) {
var value = r2 % 2 === 0;
matrix.set(r2, 6, value, true);
matrix.set(6, r2, value, true);
}
}
function setupAlignmentPattern(matrix, version2) {
var pos = AlignmentPattern.getPositions(version2);
for (var i2 = 0; i2 < pos.length; i2++) {
var row = pos[i2][0];
var col = pos[i2][1];
for (var r2 = -2; r2 <= 2; r2++) {
for (var c2 = -2; c2 <= 2; c2++) {
if (r2 === -2 || r2 === 2 || c2 === -2 || c2 === 2 || r2 === 0 && c2 === 0) {
matrix.set(row + r2, col + c2, true, true);
} else {
matrix.set(row + r2, col + c2, false, true);
}
}
}
}
}
function setupVersionInfo(matrix, version2) {
var size = matrix.size;
var bits = Version.getEncodedBits(version2);
var row, col, mod;
for (var i2 = 0; i2 < 18; i2++) {
row = Math.floor(i2 / 3);
col = i2 % 3 + size - 8 - 3;
mod = (bits >> i2 & 1) === 1;
matrix.set(row, col, mod, true);
matrix.set(col, row, mod, true);
}
}
function setupFormatInfo(matrix, errorCorrectionLevel2, maskPattern2) {
var size = matrix.size;
var bits = FormatInfo.getEncodedBits(errorCorrectionLevel2, maskPattern2);
var i2, mod;
for (i2 = 0; i2 < 15; i2++) {
mod = (bits >> i2 & 1) === 1;
if (i2 < 6) {
matrix.set(i2, 8, mod, true);
} else if (i2 < 8) {
matrix.set(i2 + 1, 8, mod, true);
} else {
matrix.set(size - 15 + i2, 8, mod, true);
}
if (i2 < 8) {
matrix.set(8, size - i2 - 1, mod, true);
} else if (i2 < 9) {
matrix.set(8, 15 - i2 - 1 + 1, mod, true);
} else {
matrix.set(8, 15 - i2 - 1, mod, true);
}
}
matrix.set(size - 8, 8, 1, true);
}
function setupData(matrix, data) {
var size = matrix.size;
var inc = -1;
var row = size - 1;
var bitIndex = 7;
var byteIndex = 0;
for (var col = size - 1; col > 0; col -= 2) {
if (col === 6)
col--;
while (true) {
for (var c2 = 0; c2 < 2; c2++) {
if (!matrix.isReserved(row, col - c2)) {
var dark = false;
if (byteIndex < data.length) {
dark = (data[byteIndex] >>> bitIndex & 1) === 1;
}
matrix.set(row, col - c2, dark);
bitIndex--;
if (bitIndex === -1) {
byteIndex++;
bitIndex = 7;
}
}
}
row += inc;
if (row < 0 || size <= row) {
row -= inc;
inc = -inc;
break;
}
}
}
}
function createData(version2, errorCorrectionLevel2, segments2) {
var buffer2 = new BitBuffer();
segments2.forEach(function(data) {
buffer2.put(data.mode.bit, 4);
buffer2.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version2));
data.write(buffer2);
});
var totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
var ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (buffer2.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
buffer2.put(0, 4);
}
while (buffer2.getLengthInBits() % 8 !== 0) {
buffer2.putBit(0);
}
var remainingByte = (dataTotalCodewordsBits - buffer2.getLengthInBits()) / 8;
for (var i2 = 0; i2 < remainingByte; i2++) {
buffer2.put(i2 % 2 ? 17 : 236, 8);
}
return createCodewords(buffer2, version2, errorCorrectionLevel2);
}
function createCodewords(bitBuffer2, version2, errorCorrectionLevel2) {
var totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
var ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
var dataTotalCodewords = totalCodewords - ecTotalCodewords;
var ecTotalBlocks = ECCode.getBlocksCount(version2, errorCorrectionLevel2);
var blocksInGroup2 = totalCodewords % ecTotalBlocks;
var blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
var totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
var dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
var dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
var ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
var rs = new ReedSolomonEncoder(ecCount);
var offset = 0;
var dcData = new Array(ecTotalBlocks);
var ecData = new Array(ecTotalBlocks);
var maxDataSize = 0;
var buffer2 = BufferUtil.from(bitBuffer2.buffer);
for (var b2 = 0; b2 < ecTotalBlocks; b2++) {
var dataSize = b2 < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
dcData[b2] = buffer2.slice(offset, offset + dataSize);
ecData[b2] = rs.encode(dcData[b2]);
offset += dataSize;
maxDataSize = Math.max(maxDataSize, dataSize);
}
var data = BufferUtil.alloc(totalCodewords);
var index2 = 0;
var i2, r2;
for (i2 = 0; i2 < maxDataSize; i2++) {
for (r2 = 0; r2 < ecTotalBlocks; r2++) {
if (i2 < dcData[r2].length) {
data[index2++] = dcData[r2][i2];
}
}
}
for (i2 = 0; i2 < ecCount; i2++) {
for (r2 = 0; r2 < ecTotalBlocks; r2++) {
data[index2++] = ecData[r2][i2];
}
}
return data;
}
function createSymbol(data, version2, errorCorrectionLevel2, maskPattern2) {
var segments2;
if (isArray(data)) {
segments2 = Segments.fromArray(data);
} else if (typeof data === "string") {
var estimatedVersion = version2;
if (!estimatedVersion) {
var rawSegments = Segments.rawSplit(data);
estimatedVersion = Version.getBestVersionForData(
rawSegments,
errorCorrectionLevel2
);
}
segments2 = Segments.fromString(data, estimatedVersion || 40);
} else {
throw new Error("Invalid data");
}
var bestVersion = Version.getBestVersionForData(
segments2,
errorCorrectionLevel2
);
if (!bestVersion) {
throw new Error("The amount of data is too big to be stored in a QR Code");
}
if (!version2) {
version2 = bestVersion;
} else if (version2 < bestVersion) {
throw new Error(
"\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
);
}
var dataBits = createData(version2, errorCorrectionLevel2, segments2);
var moduleCount = Utils$1.getSymbolSize(version2);
var modules = new BitMatrix(moduleCount);
setupFinderPattern(modules, version2);
setupTimingPattern(modules);
setupAlignmentPattern(modules, version2);
setupFormatInfo(modules, errorCorrectionLevel2, 0);
if (version2 >= 7) {
setupVersionInfo(modules, version2);
}
setupData(modules, dataBits);
if (isNaN(maskPattern2)) {
maskPattern2 = MaskPattern.getBestMask(
modules,
setupFormatInfo.bind(null, modules, errorCorrectionLevel2)
);
}
MaskPattern.applyMask(maskPattern2, modules);
setupFormatInfo(modules, errorCorrectionLevel2, maskPattern2);
return {
modules,
version: version2,
errorCorrectionLevel: errorCorrectionLevel2,
maskPattern: maskPattern2,
segments: segments2
};
}
qrcode.create = function create(data, options) {
if (typeof data === "undefined" || data === "") {
throw new Error("No input text");
}
var errorCorrectionLevel2 = ECLevel.M;
var version2;
var mask;
if (typeof options !== "undefined") {
errorCorrectionLevel2 = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
version2 = Version.from(options.version);
mask = MaskPattern.from(options.maskPattern);
if (options.toSJISFunc) {
Utils$1.setToSJISFunction(options.toSJISFunc);
}
}
return createSymbol(data, version2, errorCorrectionLevel2, mask);
};
var canvas = {};
var utils = {};
(function(exports) {
function hex2rgba(hex) {
if (typeof hex === "number") {
hex = hex.toString();
}
if (typeof hex !== "string") {
throw new Error("Color should be defined as hex string");
}
var hexCode = hex.slice().replace("#", "").split("");
if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
throw new Error("Invalid hex color: " + hex);
}
if (hexCode.length === 3 || hexCode.length === 4) {
hexCode = Array.prototype.concat.apply([], hexCode.map(function(c2) {
return [c2, c2];
}));
}
if (hexCode.length === 6)
hexCode.push("F", "F");
var hexValue = parseInt(hexCode.join(""), 16);
return {
r: hexValue >> 24 & 255,
g: hexValue >> 16 & 255,
b: hexValue >> 8 & 255,
a: hexValue & 255,
hex: "#" + hexCode.slice(0, 6).join("")
};
}
exports.getOptions = function getOptions(options) {
if (!options)
options = {};
if (!options.color)
options.color = {};
var margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
var width = options.width && options.width >= 21 ? options.width : void 0;
var scale = options.scale || 4;
return {
width,
scale: width ? 4 : scale,
margin,
color: {
dark: hex2rgba(options.color.dark || "#000000ff"),
light: hex2rgba(options.color.light || "#ffffffff")
},
type: options.type,
rendererOpts: options.rendererOpts || {}
};
};
exports.getScale = function getScale(qrSize, opts) {
return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
};
exports.getImageWidth = function getImageWidth(qrSize, opts) {
var scale = exports.getScale(qrSize, opts);
return Math.floor((qrSize + opts.margin * 2) * scale);
};
exports.qrToImageData = function qrToImageData(imgData, qr, opts) {
var size = qr.modules.size;
var data = qr.modules.data;
var scale = exports.getScale(size, opts);
var symbolSize = Math.floor((size + opts.margin * 2) * scale);
var scaledMargin = opts.margin * scale;
var palette = [opts.color.light, opts.color.dark];
for (var i2 = 0; i2 < symbolSize; i2++) {
for (var j2 = 0; j2 < symbolSize; j2++) {
var posDst = (i2 * symbolSize + j2) * 4;
var pxColor = opts.color.light;
if (i2 >= scaledMargin && j2 >= scaledMargin && i2 < symbolSize - scaledMargin && j2 < symbolSize - scaledMargin) {
var iSrc = Math.floor((i2 - scaledMargin) / scale);
var jSrc = Math.floor((j2 - scaledMargin) / scale);
pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
}
imgData[posDst++] = pxColor.r;
imgData[posDst++] = pxColor.g;
imgData[posDst++] = pxColor.b;
imgData[posDst] = pxColor.a;
}
}
};
})(utils);
(function(exports) {
var Utils2 = utils;
function clearCanvas(ctx, canvas2, size) {
ctx.clearRect(0, 0, canvas2.width, canvas2.height);
if (!canvas2.style)
canvas2.style = {};
canvas2.height = size;
canvas2.width = size;
canvas2.style.height = size + "px";
canvas2.style.width = size + "px";
}
function getCanvasElement() {
try {
return document.createElement("canvas");
} catch (e2) {
throw new Error("You need to specify a canvas element");
}
}
exports.render = function render2(qrData, canvas2, options) {
var opts = options;
var canvasEl = canvas2;
if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
opts = canvas2;
canvas2 = void 0;
}
if (!canvas2) {
canvasEl = getCanvasElement();
}
opts = Utils2.getOptions(opts);
var size = Utils2.getImageWidth(qrData.modules.size, opts);
var ctx = canvasEl.getContext("2d");
var image = ctx.createImageData(size, size);
Utils2.qrToImageData(image.data, qrData, opts);
clearCanvas(ctx, canvasEl, size);
ctx.putImageData(image, 0, 0);
return canvasEl;
};
exports.renderToDataURL = function renderToDataURL(qrData, canvas2, options) {
var opts = options;
if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
opts = canvas2;
canvas2 = void 0;
}
if (!opts)
opts = {};
var canvasEl = exports.render(qrData, canvas2, opts);
var type = opts.type || "image/png";
var rendererOpts = opts.rendererOpts || {};
return canvasEl.toDataURL(type, rendererOpts.quality);
};
})(canvas);
var svgTag = {};
var Utils = utils;
function getColorAttrib(color, attrib) {
var alpha = color.a / 255;
var str = attrib + '="' + color.hex + '"';
return alpha < 1 ? str + " " + attrib + '-opacity="' + alpha.toFixed(2).slice(1) + '"' : str;
}
function svgCmd(cmd, x2, y2) {
var str = cmd + x2;
if (typeof y2 !== "undefined")
str += " " + y2;
return str;
}
function qrToPath(data, size, margin) {
var path = "";
var moveBy = 0;
var newRow = false;
var lineLength = 0;
for (var i2 = 0; i2 < data.length; i2++) {
var col = Math.floor(i2 % size);
var row = Math.floor(i2 / size);
if (!col && !newRow)
newRow = true;
if (data[i2]) {
lineLength++;
if (!(i2 > 0 && col > 0 && data[i2 - 1])) {
path += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
moveBy = 0;
newRow = false;
}
if (!(col + 1 < size && data[i2 + 1])) {
path += svgCmd("h", lineLength);
lineLength = 0;
}
} else {
moveBy++;
}
}
return path;
}
svgTag.render = function render(qrData, options, cb) {
var opts = Utils.getOptions(options);
var size = qrData.modules.size;
var data = qrData.modules.data;
var qrcodesize = size + opts.margin * 2;
var bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
var path = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
var viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
var width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
var svgTag2 = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path + "</svg>\n";
if (typeof cb === "function") {
cb(null, svgTag2);
}
return svgTag2;
};
var canPromise = canPromise$1;
var QRCode$1 = qrcode;
var CanvasRenderer = canvas;
var SvgRenderer = svgTag;
function renderCanvas(renderFunc, canvas2, text, opts, cb) {
var args = [].slice.call(arguments, 1);
var argsNum = args.length;
var isLastArgCb = typeof args[argsNum - 1] === "function";
if (!isLastArgCb && !canPromise()) {
throw new Error("Callback required as last argument");
}
if (isLastArgCb) {
if (argsNum < 2) {
throw new Error("Too few arguments provided");
}
if (argsNum === 2) {
cb = text;
text = canvas2;
canvas2 = opts = void 0;
} else if (argsNum === 3) {
if (canvas2.getContext && typeof cb === "undefined") {
cb = opts;
opts = void 0;
} else {
cb = opts;
opts = text;
text = canvas2;
canvas2 = void 0;
}
}
} else {
if (argsNum < 1) {
throw new Error("Too few arguments provided");
}
if (argsNum === 1) {
text = canvas2;
canvas2 = opts = void 0;
} else if (argsNum === 2 && !canvas2.getContext) {
opts = text;
text = canvas2;
canvas2 = void 0;
}
return new Promise(function(resolve, reject) {
try {
var data2 = QRCode$1.create(text, opts);
resolve(renderFunc(data2, canvas2, opts));
} catch (e2) {
reject(e2);
}
});
}
try {
var data = QRCode$1.create(text, opts);
cb(null, renderFunc(data, canvas2, opts));
} catch (e2) {
cb(e2);
}
}
browser.create = QRCode$1.create;
browser.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
browser.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
browser.toString = renderCanvas.bind(null, function(data, _2, opts) {
return SvgRenderer.render(data, opts);
});
var toggleSelection = function() {
var selection = document.getSelection();
if (!selection.rangeCount) {
return function() {
};
}
var active = document.activeElement;
var ranges = [];
for (var i2 = 0; i2 < selection.rangeCount; i2++) {
ranges.push(selection.getRangeAt(i2));
}
switch (active.tagName.toUpperCase()) {
case "INPUT":
case "TEXTAREA":
active.blur();
break;
default:
active = null;
break;
}
selection.removeAllRanges();
return function() {
selection.type === "Caret" && selection.removeAllRanges();
if (!selection.rangeCount) {
ranges.forEach(function(range) {
selection.addRange(range);
});
}
active && active.focus();
};
};
var deselectCurrent = toggleSelection;
var clipboardToIE11Formatting = {
"text/plain": "Text",
"text/html": "Url",
"default": "Text"
};
var defaultMessage = "Copy to clipboard: #{key}, Enter";
function format(message) {
var copyKey = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C";
return message.replace(/#{\s*key\s*}/g, copyKey);
}
function copy$1(text, options) {
var debug, message, reselectPrevious, range, selection, mark, success = false;
if (!options) {
options = {};
}
debug = options.debug || false;
try {
reselectPrevious = deselectCurrent();
range = document.createRange();
selection = document.getSelection();
mark = document.createElement("span");
mark.textContent = text;
mark.ariaHidden = "true";
mark.style.all = "unset";
mark.style.position = "fixed";
mark.style.top = 0;
mark.style.clip = "rect(0, 0, 0, 0)";
mark.style.whiteSpace = "pre";
mark.style.webkitUserSelect = "text";
mark.style.MozUserSelect = "text";
mark.style.msUserSelect = "text";
mark.style.userSelect = "text";
mark.addEventListener("copy", function(e2) {
e2.stopPropagation();
if (options.format) {
e2.preventDefault();
if (typeof e2.clipboardData === "undefined") {
debug && console.warn("unable to use e.clipboardData");
debug && console.warn("trying IE specific stuff");
window.clipboardData.clearData();
var format2 = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting["default"];
window.clipboardData.setData(format2, text);
} else {
e2.clipboardData.clearData();
e2.clipboardData.setData(options.format, text);
}
}
if (options.onCopy) {
e2.preventDefault();
options.onCopy(e2.clipboardData);
}
});
document.body.appendChild(mark);
range.selectNodeContents(mark);
selection.addRange(range);
var successful = document.execCommand("copy");
if (!successful) {
throw new Error("copy command was unsuccessful");
}
success = true;
} catch (err) {
debug && console.error("unable to copy using execCommand: ", err);
debug && console.warn("trying IE specific stuff");
try {
window.clipboardData.setData(options.format || "text", text);
options.onCopy && options.onCopy(window.clipboardData);
success = true;
} catch (err2) {
debug && console.error("unable to copy using clipboardData: ", err2);
debug && console.error("falling back to prompt");
message = format("message" in options ? options.message : defaultMessage);
window.prompt(message, text);
}
} finally {
if (selection) {
if (typeof selection.removeRange == "function") {
selection.removeRange(range);
} else {
selection.removeAllRanges();
}
}
if (mark) {
document.body.removeChild(mark);
}
reselectPrevious();
}
return success;
}
var copyToClipboard = copy$1;
var n, u$1, i$1, t$1, r$1, o$1, f$1, e$1 = {}, c$1 = [], s$1 = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord/i;
function a$1(n2, l2) {
for (var u2 in l2)
n2[u2] = l2[u2];
return n2;
}
function v$1(n2) {
var l2 = n2.parentNode;
l2 && l2.removeChild(n2);
}
function h$1(n2, l2, u2) {
var i2, t2 = arguments, r2 = {};
for (i2 in l2)
"key" !== i2 && "ref" !== i2 && (r2[i2] = l2[i2]);
if (arguments.length > 3)
for (u2 = [u2], i2 = 3; i2 < arguments.length; i2++)
u2.push(t2[i2]);
if (null != u2 && (r2.children = u2), "function" == typeof n2 && null != n2.defaultProps)
for (i2 in n2.defaultProps)
void 0 === r2[i2] && (r2[i2] = n2.defaultProps[i2]);
return p$1(n2, r2, l2 && l2.key, l2 && l2.ref, null);
}
function p$1(l2, u2, i2, t2, r2) {
var o2 = { type: l2, props: u2, key: i2, ref: t2, __k: null, __: null, __b: 0, __e: null, __d: void 0, __c: null, constructor: void 0, __v: r2 };
return null == r2 && (o2.__v = o2), n.vnode && n.vnode(o2), o2;
}
function y$1() {
return {};
}
function d$1(n2) {
return n2.children;
}
function m$1(n2, l2) {
this.props = n2, this.context = l2;
}
function w$2(n2, l2) {
if (null == l2)
return n2.__ ? w$2(n2.__, n2.__.__k.indexOf(n2) + 1) : null;
for (var u2; l2 < n2.__k.length; l2++)
if (null != (u2 = n2.__k[l2]) && null != u2.__e)
return u2.__e;
return "function" == typeof n2.type ? w$2(n2) : null;
}
function k$1(n2) {
var l2, u2;
if (null != (n2 = n2.__) && null != n2.__c) {
for (n2.__e = n2.__c.base = null, l2 = 0; l2 < n2.__k.length; l2++)
if (null != (u2 = n2.__k[l2]) && null != u2.__e) {
n2.__e = n2.__c.base = u2.__e;
break;
}
return k$1(n2);
}
}
function g$1(l2) {
(!l2.__d && (l2.__d = true) && u$1.push(l2) && !i$1++ || r$1 !== n.debounceRendering) && ((r$1 = n.debounceRendering) || t$1)(_$2);
}
function _$2() {
for (var n2; i$1 = u$1.length; )
n2 = u$1.sort(function(n3, l2) {
return n3.__v.__b - l2.__v.__b;
}), u$1 = [], n2.some(function(n3) {
var l2, u2, i2, t2, r2, o2, f2;
n3.__d && (o2 = (r2 = (l2 = n3).__v).__e, (f2 = l2.__P) && (u2 = [], (i2 = a$1({}, r2)).__v = i2, t2 = A$2(f2, r2, i2, l2.__n, void 0 !== f2.ownerSVGElement, null, u2, null == o2 ? w$2(r2) : o2), T$2(u2, r2), t2 != o2 && k$1(r2)));
});
}
function b(n2, l2, u2, i2, t2, r2, o2, f2, s2) {
var a2, h2, p2, y2, d2, m2, k2, g2 = u2 && u2.__k || c$1, _2 = g2.length;
if (f2 == e$1 && (f2 = null != r2 ? r2[0] : _2 ? w$2(u2, 0) : null), a2 = 0, l2.__k = x$1(l2.__k, function(u3) {
if (null != u3) {
if (u3.__ = l2, u3.__b = l2.__b + 1, null === (p2 = g2[a2]) || p2 && u3.key == p2.key && u3.type === p2.type)
g2[a2] = void 0;
else
for (h2 = 0; h2 < _2; h2++) {
if ((p2 = g2[h2]) && u3.key == p2.key && u3.type === p2.type) {
g2[h2] = void 0;
break;
}
p2 = null;
}
if (y2 = A$2(n2, u3, p2 = p2 || e$1, i2, t2, r2, o2, f2, s2), (h2 = u3.ref) && p2.ref != h2 && (k2 || (k2 = []), p2.ref && k2.push(p2.ref, null, u3), k2.push(h2, u3.__c || y2, u3)), null != y2) {
var c2;
if (null == m2 && (m2 = y2), void 0 !== u3.__d)
c2 = u3.__d, u3.__d = void 0;
else if (r2 == p2 || y2 != f2 || null == y2.parentNode) {
n:
if (null == f2 || f2.parentNode !== n2)
n2.appendChild(y2), c2 = null;
else {
for (d2 = f2, h2 = 0; (d2 = d2.nextSibling) && h2 < _2; h2 += 2)
if (d2 == y2)
break n;
n2.insertBefore(y2, f2), c2 = f2;
}
"option" == l2.type && (n2.value = "");
}
f2 = void 0 !== c2 ? c2 : y2.nextSibling, "function" == typeof l2.type && (l2.__d = f2);
} else
f2 && p2.__e == f2 && f2.parentNode != n2 && (f2 = w$2(p2));
}
return a2++, u3;
}), l2.__e = m2, null != r2 && "function" != typeof l2.type)
for (a2 = r2.length; a2--; )
null != r2[a2] && v$1(r2[a2]);
for (a2 = _2; a2--; )
null != g2[a2] && D$1(g2[a2], g2[a2]);
if (k2)
for (a2 = 0; a2 < k2.length; a2++)
j$1(k2[a2], k2[++a2], k2[++a2]);
}
function x$1(n2, l2, u2) {
if (null == u2 && (u2 = []), null == n2 || "boolean" == typeof n2)
l2 && u2.push(l2(null));
else if (Array.isArray(n2))
for (var i2 = 0; i2 < n2.length; i2++)
x$1(n2[i2], l2, u2);
else
u2.push(l2 ? l2("string" == typeof n2 || "number" == typeof n2 ? p$1(null, n2, null, null, n2) : null != n2.__e || null != n2.__c ? p$1(n2.type, n2.props, n2.key, null, n2.__v) : n2) : n2);
return u2;
}
function P$1(n2, l2, u2, i2, t2) {
var r2;
for (r2 in u2)
"children" === r2 || "key" === r2 || r2 in l2 || N$1(n2, r2, null, u2[r2], i2);
for (r2 in l2)
t2 && "function" != typeof l2[r2] || "children" === r2 || "key" === r2 || "value" === r2 || "checked" === r2 || u2[r2] === l2[r2] || N$1(n2, r2, l2[r2], u2[r2], i2);
}
function C$1(n2, l2, u2) {
"-" === l2[0] ? n2.setProperty(l2, u2) : n2[l2] = "number" == typeof u2 && false === s$1.test(l2) ? u2 + "px" : null == u2 ? "" : u2;
}
function N$1(n2, l2, u2, i2, t2) {
var r2, o2, f2, e2, c2;
if (t2 ? "className" === l2 && (l2 = "class") : "class" === l2 && (l2 = "className"), "style" === l2)
if (r2 = n2.style, "string" == typeof u2)
r2.cssText = u2;
else {
if ("string" == typeof i2 && (r2.cssText = "", i2 = null), i2)
for (e2 in i2)
u2 && e2 in u2 || C$1(r2, e2, "");
if (u2)
for (c2 in u2)
i2 && u2[c2] === i2[c2] || C$1(r2, c2, u2[c2]);
}
else
"o" === l2[0] && "n" === l2[1] ? (o2 = l2 !== (l2 = l2.replace(/Capture$/, "")), f2 = l2.toLowerCase(), l2 = (f2 in n2 ? f2 : l2).slice(2), u2 ? (i2 || n2.addEventListener(l2, z$1, o2), (n2.l || (n2.l = {}))[l2] = u2) : n2.removeEventListener(l2, z$1, o2)) : "list" !== l2 && "tagName" !== l2 && "form" !== l2 && "type" !== l2 && "size" !== l2 && !t2 && l2 in n2 ? n2[l2] = null == u2 ? "" : u2 : "function" != typeof u2 && "dangerouslySetInnerHTML" !== l2 && (l2 !== (l2 = l2.replace(/^xlink:?/, "")) ? null == u2 || false === u2 ? n2.removeAttributeNS("http://www.w3.org/1999/xlink", l2.toLowerCase()) : n2.setAttributeNS("http://www.w3.org/1999/xlink", l2.toLowerCase(), u2) : null == u2 || false === u2 && !/^ar/.test(l2) ? n2.removeAttribute(l2) : n2.setAttribute(l2, u2));
}
function z$1(l2) {
this.l[l2.type](n.event ? n.event(l2) : l2);
}
function A$2(l2, u2, i2, t2, r2, o2, f2, e2, c2) {
var s2, v2, h2, p2, y2, w2, k2, g2, _2, x2, P2 = u2.type;
if (void 0 !== u2.constructor)
return null;
(s2 = n.__b) && s2(u2);
try {
n:
if ("function" == typeof P2) {
if (g2 = u2.props, _2 = (s2 = P2.contextType) && t2[s2.__c], x2 = s2 ? _2 ? _2.props.value : s2.__ : t2, i2.__c ? k2 = (v2 = u2.__c = i2.__c).__ = v2.__E : ("prototype" in P2 && P2.prototype.render ? u2.__c = v2 = new P2(g2, x2) : (u2.__c = v2 = new m$1(g2, x2), v2.constructor = P2, v2.render = E$2), _2 && _2.sub(v2), v2.props = g2, v2.state || (v2.state = {}), v2.context = x2, v2.__n = t2, h2 = v2.__d = true, v2.__h = []), null == v2.__s && (v2.__s = v2.state), null != P2.getDerivedStateFromProps && (v2.__s == v2.state && (v2.__s = a$1({}, v2.__s)), a$1(v2.__s, P2.getDerivedStateFromProps(g2, v2.__s))), p2 = v2.props, y2 = v2.state, h2)
null == P2.getDerivedStateFromProps && null != v2.componentWillMount && v2.componentWillMount(), null != v2.componentDidMount && v2.__h.push(v2.componentDidMount);
else {
if (null == P2.getDerivedStateFromProps && g2 !== p2 && null != v2.componentWillReceiveProps && v2.componentWillReceiveProps(g2, x2), !v2.__e && null != v2.shouldComponentUpdate && false === v2.shouldComponentUpdate(g2, v2.__s, x2) || u2.__v === i2.__v && !v2.__) {
for (v2.props = g2, v2.state = v2.__s, u2.__v !== i2.__v && (v2.__d = false), v2.__v = u2, u2.__e = i2.__e, u2.__k = i2.__k, v2.__h.length && f2.push(v2), s2 = 0; s2 < u2.__k.length; s2++)
u2.__k[s2] && (u2.__k[s2].__ = u2);
break n;
}
null != v2.componentWillUpdate && v2.componentWillUpdate(g2, v2.__s, x2), null != v2.componentDidUpdate && v2.__h.push(function() {
v2.componentDidUpdate(p2, y2, w2);
});
}
v2.context = x2, v2.props = g2, v2.state = v2.__s, (s2 = n.__r) && s2(u2), v2.__d = false, v2.__v = u2, v2.__P = l2, s2 = v2.render(v2.props, v2.state, v2.context), u2.__k = null != s2 && s2.type == d$1 && null == s2.key ? s2.props.children : Array.isArray(s2) ? s2 : [s2], null != v2.getChildContext && (t2 = a$1(a$1({}, t2), v2.getChildContext())), h2 || null == v2.getSnapshotBeforeUpdate || (w2 = v2.getSnapshotBeforeUpdate(p2, y2)), b(l2, u2, i2, t2, r2, o2, f2, e2, c2), v2.base = u2.__e, v2.__h.length && f2.push(v2), k2 && (v2.__E = v2.__ = null), v2.__e = false;
} else
null == o2 && u2.__v === i2.__v ? (u2.__k = i2.__k, u2.__e = i2.__e) : u2.__e = $$1(i2.__e, u2, i2, t2, r2, o2, f2, c2);
(s2 = n.diffed) && s2(u2);
} catch (l3) {
u2.__v = null, n.__e(l3, u2, i2);
}
return u2.__e;
}
function T$2(l2, u2) {
n.__c && n.__c(u2, l2), l2.some(function(u3) {
try {
l2 = u3.__h, u3.__h = [], l2.some(function(n2) {
n2.call(u3);
});
} catch (l3) {
n.__e(l3, u3.__v);
}
});
}
function $$1(n2, l2, u2, i2, t2, r2, o2, f2) {
var s2, a2, v2, h2, p2, y2 = u2.props, d2 = l2.props;
if (t2 = "svg" === l2.type || t2, null != r2) {
for (s2 = 0; s2 < r2.length; s2++)
if (null != (a2 = r2[s2]) && ((null === l2.type ? 3 === a2.nodeType : a2.localName === l2.type) || n2 == a2)) {
n2 = a2, r2[s2] = null;
break;
}
}
if (null == n2) {
if (null === l2.type)
return document.createTextNode(d2);
n2 = t2 ? document.createElementNS("http://www.w3.org/2000/svg", l2.type) : document.createElement(l2.type, d2.is && { is: d2.is }), r2 = null, f2 = false;
}
if (null === l2.type)
y2 !== d2 && n2.data != d2 && (n2.data = d2);
else {
if (null != r2 && (r2 = c$1.slice.call(n2.childNodes)), v2 = (y2 = u2.props || e$1).dangerouslySetInnerHTML, h2 = d2.dangerouslySetInnerHTML, !f2) {
if (y2 === e$1)
for (y2 = {}, p2 = 0; p2 < n2.attributes.length; p2++)
y2[n2.attributes[p2].name] = n2.attributes[p2].value;
(h2 || v2) && (h2 && v2 && h2.__html == v2.__html || (n2.innerHTML = h2 && h2.__html || ""));
}
P$1(n2, d2, y2, t2, f2), h2 ? l2.__k = [] : (l2.__k = l2.props.children, b(n2, l2, u2, i2, "foreignObject" !== l2.type && t2, r2, o2, e$1, f2)), f2 || ("value" in d2 && void 0 !== (s2 = d2.value) && s2 !== n2.value && N$1(n2, "value", s2, y2.value, false), "checked" in d2 && void 0 !== (s2 = d2.checked) && s2 !== n2.checked && N$1(n2, "checked", s2, y2.checked, false));
}
return n2;
}
function j$1(l2, u2, i2) {
try {
"function" == typeof l2 ? l2(u2) : l2.current = u2;
} catch (l3) {
n.__e(l3, i2);
}
}
function D$1(l2, u2, i2) {
var t2, r2, o2;
if (n.unmount && n.unmount(l2), (t2 = l2.ref) && (t2.current && t2.current !== l2.__e || j$1(t2, null, u2)), i2 || "function" == typeof l2.type || (i2 = null != (r2 = l2.__e)), l2.__e = l2.__d = void 0, null != (t2 = l2.__c)) {
if (t2.componentWillUnmount)
try {
t2.componentWillUnmount();
} catch (l3) {
n.__e(l3, u2);
}
t2.base = t2.__P = null;
}
if (t2 = l2.__k)
for (o2 = 0; o2 < t2.length; o2++)
t2[o2] && D$1(t2[o2], u2, i2);
null != r2 && v$1(r2);
}
function E$2(n2, l2, u2) {
return this.constructor(n2, u2);
}
function H$1(l2, u2, i2) {
var t2, r2, f2;
n.__ && n.__(l2, u2), r2 = (t2 = i2 === o$1) ? null : i2 && i2.__k || u2.__k, l2 = h$1(d$1, null, [l2]), f2 = [], A$2(u2, (t2 ? u2 : i2 || u2).__k = l2, r2 || e$1, e$1, void 0 !== u2.ownerSVGElement, i2 && !t2 ? [i2] : r2 ? null : c$1.slice.call(u2.childNodes), f2, i2 || e$1, t2), T$2(f2, l2);
}
function I$1(n2, l2) {
H$1(n2, l2, o$1);
}
function L$1(n2, l2) {
var u2, i2;
for (i2 in l2 = a$1(a$1({}, n2.props), l2), arguments.length > 2 && (l2.children = c$1.slice.call(arguments, 2)), u2 = {}, l2)
"key" !== i2 && "ref" !== i2 && (u2[i2] = l2[i2]);
return p$1(n2.type, u2, l2.key || n2.key, l2.ref || n2.ref, null);
}
function M$1(n2) {
var l2 = {}, u2 = { __c: "__cC" + f$1++, __: n2, Consumer: function(n3, l3) {
return n3.children(l3);
}, Provider: function(n3) {
var i2, t2 = this;
return this.getChildContext || (i2 = [], this.getChildContext = function() {
return l2[u2.__c] = t2, l2;
}, this.shouldComponentUpdate = function(n4) {
t2.props.value !== n4.value && i2.some(function(l3) {
l3.context = n4.value, g$1(l3);
});
}, this.sub = function(n4) {
i2.push(n4);
var l3 = n4.componentWillUnmount;
n4.componentWillUnmount = function() {
i2.splice(i2.indexOf(n4), 1), l3 && l3.call(n4);
};
}), n3.children;
} };
return u2.Consumer.contextType = u2, u2.Provider.__ = u2, u2;
}
n = { __e: function(n2, l2) {
for (var u2, i2; l2 = l2.__; )
if ((u2 = l2.__c) && !u2.__)
try {
if (u2.constructor && null != u2.constructor.getDerivedStateFromError && (i2 = true, u2.setState(u2.constructor.getDerivedStateFromError(n2))), null != u2.componentDidCatch && (i2 = true, u2.componentDidCatch(n2)), i2)
return g$1(u2.__E = u2);
} catch (l3) {
n2 = l3;
}
throw n2;
} }, m$1.prototype.setState = function(n2, l2) {
var u2;
u2 = this.__s !== this.state ? this.__s : this.__s = a$1({}, this.state), "function" == typeof n2 && (n2 = n2(u2, this.props)), n2 && a$1(u2, n2), null != n2 && this.__v && (l2 && this.__h.push(l2), g$1(this));
}, m$1.prototype.forceUpdate = function(n2) {
this.__v && (this.__e = true, n2 && this.__h.push(n2), g$1(this));
}, m$1.prototype.render = d$1, u$1 = [], i$1 = 0, t$1 = "function" == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout, o$1 = e$1, f$1 = 0;
var t, u, r, i = 0, o = [], c = n.__r, f = n.diffed, e = n.__c, a = n.unmount;
function v(t2, r2) {
n.__h && n.__h(u, t2, i || r2), i = 0;
var o2 = u.__H || (u.__H = { __: [], __h: [] });
return t2 >= o2.__.length && o2.__.push({}), o2.__[t2];
}
function m(n2) {
return i = 1, p(E$1, n2);
}
function p(n2, r2, i2) {
var o2 = v(t++, 2);
return o2.__c || (o2.__c = u, o2.__ = [i2 ? i2(r2) : E$1(void 0, r2), function(t2) {
var u2 = n2(o2.__[0], t2);
o2.__[0] !== u2 && (o2.__[0] = u2, o2.__c.setState({}));
}]), o2.__;
}
function l(r2, i2) {
var o2 = v(t++, 3);
!n.__s && x(o2.__H, i2) && (o2.__ = r2, o2.__H = i2, u.__H.__h.push(o2));
}
function y(r2, i2) {
var o2 = v(t++, 4);
!n.__s && x(o2.__H, i2) && (o2.__ = r2, o2.__H = i2, u.__h.push(o2));
}
function d(n2) {
return i = 5, h(function() {
return { current: n2 };
}, []);
}
function s(n2, t2, u2) {
i = 6, y(function() {
"function" == typeof n2 ? n2(t2()) : n2 && (n2.current = t2());
}, null == u2 ? u2 : u2.concat(n2));
}
function h(n2, u2) {
var r2 = v(t++, 7);
return x(r2.__H, u2) ? (r2.__H = u2, r2.__h = n2, r2.__ = n2()) : r2.__;
}
function T$1(n2, t2) {
return i = 8, h(function() {
return n2;
}, t2);
}
function w$1(n2) {
var r2 = u.context[n2.__c], i2 = v(t++, 9);
return i2.__c = n2, r2 ? (null == i2.__ && (i2.__ = true, r2.sub(u)), r2.props.value) : n2.__;
}
function A$1(t2, u2) {
n.useDebugValue && n.useDebugValue(u2 ? u2(t2) : t2);
}
function F$1(n2) {
var r2 = v(t++, 10), i2 = m();
return r2.__ = n2, u.componentDidCatch || (u.componentDidCatch = function(n3) {
r2.__ && r2.__(n3), i2[1](n3);
}), [i2[0], function() {
i2[1](void 0);
}];
}
function _$1() {
o.some(function(t2) {
if (t2.__P)
try {
t2.__H.__h.forEach(g), t2.__H.__h.forEach(q$1), t2.__H.__h = [];
} catch (u2) {
return t2.__H.__h = [], n.__e(u2, t2.__v), true;
}
}), o = [];
}
function g(n2) {
n2.t && n2.t();
}
function q$1(n2) {
var t2 = n2.__();
"function" == typeof t2 && (n2.t = t2);
}
function x(n2, t2) {
return !n2 || t2.some(function(t3, u2) {
return t3 !== n2[u2];
});
}
function E$1(n2, t2) {
return "function" == typeof t2 ? t2(n2) : t2;
}
n.__r = function(n2) {
c && c(n2), t = 0, (u = n2.__c).__H && (u.__H.__h.forEach(g), u.__H.__h.forEach(q$1), u.__H.__h = []);
}, n.diffed = function(t2) {
f && f(t2);
var u2 = t2.__c;
if (u2) {
var i2 = u2.__H;
i2 && i2.__h.length && (1 !== o.push(u2) && r === n.requestAnimationFrame || ((r = n.requestAnimationFrame) || function(n2) {
var t3, u3 = function() {
clearTimeout(r2), cancelAnimationFrame(t3), setTimeout(n2);
}, r2 = setTimeout(u3, 100);
"undefined" != typeof window && (t3 = requestAnimationFrame(u3));
})(_$1));
}
}, n.__c = function(t2, u2) {
u2.some(function(t3) {
try {
t3.__h.forEach(g), t3.__h = t3.__h.filter(function(n2) {
return !n2.__ || q$1(n2);
});
} catch (r2) {
u2.some(function(n2) {
n2.__h && (n2.__h = []);
}), u2 = [], n.__e(r2, t3.__v);
}
}), e && e(t2, u2);
}, n.unmount = function(t2) {
a && a(t2);
var u2 = t2.__c;
if (u2) {
var r2 = u2.__H;
if (r2)
try {
r2.__.forEach(function(n2) {
return n2.t && n2.t();
});
} catch (t3) {
n.__e(t3, u2.__v);
}
}
};
function E(n2, t2) {
for (var e2 in t2)
n2[e2] = t2[e2];
return n2;
}
function w(n2, t2) {
for (var e2 in n2)
if ("__source" !== e2 && !(e2 in t2))
return true;
for (var r2 in t2)
if ("__source" !== r2 && n2[r2] !== t2[r2])
return true;
return false;
}
var C = function(n2) {
var t2, e2;
function r2(t3) {
var e3;
return (e3 = n2.call(this, t3) || this).isPureReactComponent = true, e3;
}
return e2 = n2, (t2 = r2).prototype = Object.create(e2.prototype), t2.prototype.constructor = t2, t2.__proto__ = e2, r2.prototype.shouldComponentUpdate = function(n3, t3) {
return w(this.props, n3) || w(this.state, t3);
}, r2;
}(m$1);
function _(n2, t2) {
function e2(n3) {
var e3 = this.props.ref, r3 = e3 == n3.ref;
return !r3 && e3 && (e3.call ? e3(null) : e3.current = null), t2 ? !t2(this.props, n3) || !r3 : w(this.props, n3);
}
function r2(t3) {
return this.shouldComponentUpdate = e2, h$1(n2, E({}, t3));
}
return r2.prototype.isReactComponent = true, r2.displayName = "Memo(" + (n2.displayName || n2.name) + ")", r2.t = true, r2;
}
var A = n.__b;
function S(n2) {
function t2(t3) {
var e2 = E({}, t3);
return delete e2.ref, n2(e2, t3.ref);
}
return t2.prototype.isReactComponent = t2.t = true, t2.displayName = "ForwardRef(" + (n2.displayName || n2.name) + ")", t2;
}
n.__b = function(n2) {
n2.type && n2.type.t && n2.ref && (n2.props.ref = n2.ref, n2.ref = null), A && A(n2);
};
var k = function(n2, t2) {
return n2 ? x$1(n2).reduce(function(n3, e2, r2) {
return n3.concat(t2(e2, r2));
}, []) : null;
}, R = { map: k, forEach: k, count: function(n2) {
return n2 ? x$1(n2).length : 0;
}, only: function(n2) {
if (1 !== (n2 = x$1(n2)).length)
throw new Error("Children.only() expects only one child.");
return n2[0];
}, toArray: x$1 }, F = n.__e;
function N(n2) {
return n2 && ((n2 = E({}, n2)).__c = null, n2.__k = n2.__k && n2.__k.map(N)), n2;
}
function U() {
this.__u = 0, this.o = null, this.__b = null;
}
function M(n2) {
var t2 = n2.__.__c;
return t2 && t2.u && t2.u(n2);
}
function L(n2) {
var t2, e2, r2;
function o2(o3) {
if (t2 || (t2 = n2()).then(function(n3) {
e2 = n3.default || n3;
}, function(n3) {
r2 = n3;
}), r2)
throw r2;
if (!e2)
throw t2;
return h$1(e2, o3);
}
return o2.displayName = "Lazy", o2.t = true, o2;
}
function O() {
this.i = null, this.l = null;
}
n.__e = function(n2, t2, e2) {
if (n2.then) {
for (var r2, o2 = t2; o2 = o2.__; )
if ((r2 = o2.__c) && r2.__c)
return r2.__c(n2, t2.__c);
}
F(n2, t2, e2);
}, (U.prototype = new m$1()).__c = function(n2, t2) {
var e2 = this;
null == e2.o && (e2.o = []), e2.o.push(t2);
var r2 = M(e2.__v), o2 = false, u2 = function() {
o2 || (o2 = true, r2 ? r2(i2) : i2());
};
t2.__c = t2.componentWillUnmount, t2.componentWillUnmount = function() {
u2(), t2.__c && t2.__c();
};
var i2 = function() {
var n3;
if (!--e2.__u)
for (e2.__v.__k[0] = e2.state.u, e2.setState({ u: e2.__b = null }); n3 = e2.o.pop(); )
n3.forceUpdate();
};
e2.__u++ || e2.setState({ u: e2.__b = e2.__v.__k[0] }), n2.then(u2, u2);
}, U.prototype.render = function(n2, t2) {
return this.__b && (this.__v.__k[0] = N(this.__b), this.__b = null), [h$1(m$1, null, t2.u ? null : n2.children), t2.u && n2.fallback];
};
var P = function(n2, t2, e2) {
if (++e2[1] === e2[0] && n2.l.delete(t2), n2.props.revealOrder && ("t" !== n2.props.revealOrder[0] || !n2.l.size))
for (e2 = n2.i; e2; ) {
for (; e2.length > 3; )
e2.pop()();
if (e2[1] < e2[0])
break;
n2.i = e2 = e2[2];
}
};
(O.prototype = new m$1()).u = function(n2) {
var t2 = this, e2 = M(t2.__v), r2 = t2.l.get(n2);
return r2[0]++, function(o2) {
var u2 = function() {
t2.props.revealOrder ? (r2.push(o2), P(t2, n2, r2)) : o2();
};
e2 ? e2(u2) : u2();
};
}, O.prototype.render = function(n2) {
this.i = null, this.l = /* @__PURE__ */ new Map();
var t2 = x$1(n2.children);
n2.revealOrder && "b" === n2.revealOrder[0] && t2.reverse();
for (var e2 = t2.length; e2--; )
this.l.set(t2[e2], this.i = [1, 0, this.i]);
return n2.children;
}, O.prototype.componentDidUpdate = O.prototype.componentDidMount = function() {
var n2 = this;
n2.l.forEach(function(t2, e2) {
P(n2, e2, t2);
});
};
var W = function() {
function n2() {
}
var t2 = n2.prototype;
return t2.getChildContext = function() {
return this.props.context;
}, t2.render = function(n3) {
return n3.children;
}, n2;
}();
function j(n2) {
var t2 = this, e2 = n2.container, r2 = h$1(W, { context: t2.context }, n2.vnode);
return t2.s && t2.s !== e2 && (t2.v.parentNode && t2.s.removeChild(t2.v), D$1(t2.h), t2.p = false), n2.vnode ? t2.p ? (e2.__k = t2.__k, H$1(r2, e2), t2.__k = e2.__k) : (t2.v = document.createTextNode(""), I$1("", e2), e2.appendChild(t2.v), t2.p = true, t2.s = e2, H$1(r2, e2, t2.v), t2.__k = t2.v.__k) : t2.p && (t2.v.parentNode && t2.s.removeChild(t2.v), D$1(t2.h)), t2.h = r2, t2.componentWillUnmount = function() {
t2.v.parentNode && t2.s.removeChild(t2.v), D$1(t2.h);
}, null;
}
function z(n2, t2) {
return h$1(j, { vnode: n2, container: t2 });
}
var D = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
m$1.prototype.isReactComponent = {};
var H = "undefined" != typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103;
function T(n2, t2, e2) {
if (null == t2.__k)
for (; t2.firstChild; )
t2.removeChild(t2.firstChild);
return H$1(n2, t2), "function" == typeof e2 && e2(), n2 ? n2.__c : null;
}
function V(n2, t2, e2) {
return I$1(n2, t2), "function" == typeof e2 && e2(), n2 ? n2.__c : null;
}
var Z = n.event;
function I(n2, t2) {
n2["UNSAFE_" + t2] && !n2[t2] && Object.defineProperty(n2, t2, { configurable: false, get: function() {
return this["UNSAFE_" + t2];
}, set: function(n3) {
this["UNSAFE_" + t2] = n3;
} });
}
n.event = function(n2) {
Z && (n2 = Z(n2)), n2.persist = function() {
};
var t2 = false, e2 = false, r2 = n2.stopPropagation;
n2.stopPropagation = function() {
r2.call(n2), t2 = true;
};
var o2 = n2.preventDefault;
return n2.preventDefault = function() {
o2.call(n2), e2 = true;
}, n2.isPropagationStopped = function() {
return t2;
}, n2.isDefaultPrevented = function() {
return e2;
}, n2.nativeEvent = n2;
};
var $ = { configurable: true, get: function() {
return this.class;
} }, q = n.vnode;
n.vnode = function(n2) {
n2.$$typeof = H;
var t2 = n2.type, e2 = n2.props;
if (t2) {
if (e2.class != e2.className && ($.enumerable = "className" in e2, null != e2.className && (e2.class = e2.className), Object.defineProperty(e2, "className", $)), "function" != typeof t2) {
var r2, o2, u2;
for (u2 in e2.defaultValue && void 0 !== e2.value && (e2.value || 0 === e2.value || (e2.value = e2.defaultValue), delete e2.defaultValue), Array.isArray(e2.value) && e2.multiple && "select" === t2 && (x$1(e2.children).forEach(function(n3) {
-1 != e2.value.indexOf(n3.props.value) && (n3.props.selected = true);
}), delete e2.value), e2)
if (r2 = D.test(u2))
break;
if (r2)
for (u2 in o2 = n2.props = {}, e2)
o2[D.test(u2) ? u2.replace(/[A-Z0-9]/, "-$&").toLowerCase() : u2] = e2[u2];
}
!function(t3) {
var e3 = n2.type, r3 = n2.props;
if (r3 && "string" == typeof e3) {
var o3 = {};
for (var u3 in r3)
/^on(Ani|Tra|Tou)/.test(u3) && (r3[u3.toLowerCase()] = r3[u3], delete r3[u3]), o3[u3.toLowerCase()] = u3;
if (o3.ondoubleclick && (r3.ondblclick = r3[o3.ondoubleclick], delete r3[o3.ondoubleclick]), o3.onbeforeinput && (r3.onbeforeinput = r3[o3.onbeforeinput], delete r3[o3.onbeforeinput]), o3.onchange && ("textarea" === e3 || "input" === e3.toLowerCase() && !/^fil|che|ra/i.test(r3.type))) {
var i2 = o3.oninput || "oninput";
r3[i2] || (r3[i2] = r3[o3.onchange], delete r3[o3.onchange]);
}
}
}(), "function" == typeof t2 && !t2.m && t2.prototype && (I(t2.prototype, "componentWillMount"), I(t2.prototype, "componentWillReceiveProps"), I(t2.prototype, "componentWillUpdate"), t2.m = true);
}
q && q(n2);
};
var B = "16.8.0";
function G(n2) {
return h$1.bind(null, n2);
}
function J(n2) {
return !!n2 && n2.$$typeof === H;
}
function K(n2) {
return J(n2) ? L$1.apply(null, arguments) : n2;
}
function Q(n2) {
return !!n2.__k && (H$1(null, n2), true);
}
function X(n2) {
return n2 && (n2.base || 1 === n2.nodeType && n2) || null;
}
var Y = function(n2, t2) {
return n2(t2);
};
const compat_module = { useState: m, useReducer: p, useEffect: l, useLayoutEffect: y, useRef: d, useImperativeHandle: s, useMemo: h, useCallback: T$1, useContext: w$1, useDebugValue: A$1, version: "16.8.0", Children: R, render: T, hydrate: T, unmountComponentAtNode: Q, createPortal: z, createElement: h$1, createContext: M$1, createFactory: G, cloneElement: K, createRef: y$1, Fragment: d$1, isValidElement: J, findDOMNode: X, Component: m$1, PureComponent: C, memo: _, forwardRef: S, unstable_batchedUpdates: Y, Suspense: U, SuspenseList: O, lazy: L };
const compat_module$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
__proto__: null,
Children: R,
Component: m$1,
Fragment: d$1,
PureComponent: C,
Suspense: U,
SuspenseList: O,
cloneElement: K,
createContext: M$1,
createElement: h$1,
createFactory: G,
createPortal: z,
createRef: y$1,
default: compat_module,
findDOMNode: X,
forwardRef: S,
hydrate: V,
isValidElement: J,
lazy: L,
memo: _,
render: T,
unmountComponentAtNode: Q,
unstable_batchedUpdates: Y,
useCallback: T$1,
useContext: w$1,
useDebugValue: A$1,
useEffect: l,
useErrorBoundary: F$1,
useImperativeHandle: s,
useLayoutEffect: y,
useMemo: h,
useReducer: p,
useRef: d,
useState: m,
version: B
}, Symbol.toStringTag, { value: "Module" }));
const require$$3 = /* @__PURE__ */ getAugmentedNamespace(compat_module$1);
function _interopDefault(ex) {
return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex;
}
var browserUtils = require$$0;
var QRCode = _interopDefault(browser);
var copy2 = _interopDefault(copyToClipboard);
var React = require$$3;
function open(uri) {
QRCode.toString(uri, {
type: "terminal"
}).then(console.log);
}
var WALLETCONNECT_STYLE_SHEET = ':root {\n --animation-duration: 300ms;\n}\n\n@keyframes fadeIn {\n from {\n opacity: 0;\n }\n to {\n opacity: 1;\n }\n}\n\n@keyframes fadeOut {\n from {\n opacity: 1;\n }\n to {\n opacity: 0;\n }\n}\n\n.animated {\n animation-duration: var(--animation-duration);\n animation-fill-mode: both;\n}\n\n.fadeIn {\n animation-name: fadeIn;\n}\n\n.fadeOut {\n animation-name: fadeOut;\n}\n\n#walletconnect-wrapper {\n -webkit-user-select: none;\n align-items: center;\n display: flex;\n height: 100%;\n justify-content: center;\n left: 0;\n pointer-events: none;\n position: fixed;\n top: 0;\n user-select: none;\n width: 100%;\n z-index: 99999999999999;\n}\n\n.walletconnect-modal__headerLogo {\n height: 21px;\n}\n\n.walletconnect-modal__header p {\n color: #ffffff;\n font-size: 20px;\n font-weight: 600;\n margin: 0;\n align-items: flex-start;\n display: flex;\n flex: 1;\n margin-left: 5px;\n}\n\n.walletconnect-modal__close__wrapper {\n position: absolute;\n top: 0px;\n right: 0px;\n z-index: 10000;\n background: white;\n border-radius: 26px;\n padding: 6px;\n box-sizing: border-box;\n width: 26px;\n height: 26px;\n cursor: pointer;\n}\n\n.walletconnect-modal__close__icon {\n position: relative;\n top: 7px;\n right: 0;\n display: flex;\n align-items: center;\n justify-content: center;\n transform: rotate(45deg);\n}\n\n.walletconnect-modal__close__line1 {\n position: absolute;\n width: 100%;\n border: 1px solid rgb(48, 52, 59);\n}\n\n.walletconnect-modal__close__line2 {\n position: absolute;\n width: 100%;\n border: 1px solid rgb(48, 52, 59);\n transform: rotate(90deg);\n}\n\n.walletconnect-qrcode__base {\n -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n background: rgba(37, 41, 46, 0.95);\n height: 100%;\n left: 0;\n pointer-events: auto;\n position: fixed;\n top: 0;\n transition: 0.4s cubic-bezier(0.19, 1, 0.22, 1);\n width: 100%;\n will-change: opacity;\n padding: 40px;\n box-sizing: border-box;\n}\n\n.walletconnect-qrcode__text {\n color: rgba(60, 66, 82, 0.6);\n font-size: 16px;\n font-weight: 600;\n letter-spacing: 0;\n line-height: 1.1875em;\n margin: 10px 0 20px 0;\n text-align: center;\n width: 100%;\n}\n\n@media only screen and (max-width: 768px) {\n .walletconnect-qrcode__text {\n font-size: 4vw;\n }\n}\n\n@media only screen and (max-width: 320px) {\n .walletconnect-qrcode__text {\n font-size: 14px;\n }\n}\n\n.walletconnect-qrcode__image {\n width: calc(100% - 30px);\n box-sizing: border-box;\n cursor: none;\n margin: 0 auto;\n}\n\n.walletconnect-qrcode__notification {\n position: absolute;\n bottom: 0;\n left: 0;\n right: 0;\n font-size: 16px;\n padding: 16px 20px;\n border-radius: 16px;\n text-align: center;\n transition: all 0.1s ease-in-out;\n background: white;\n color: black;\n margin-bottom: -60px;\n opacity: 0;\n}\n\n.walletconnect-qrcode__notification.notification__show {\n opacity: 1;\n}\n\n@media only screen and (max-width: 768px) {\n .walletconnect-modal__header {\n height: 130px;\n }\n .walletconnect-modal__base {\n overflow: auto;\n }\n}\n\n@media only screen and (min-device-width: 415px) and (max-width: 768px) {\n #content {\n max-width: 768px;\n box-sizing: border-box;\n }\n}\n\n@media only screen and (min-width: 375px) and (max-width: 415px) {\n #content {\n max-width: 414px;\n box-sizing: border-box;\n }\n}\n\n@media only screen and (min-width: 320px) and (max-width: 375px) {\n #content {\n max-width: 375px;\n box-sizing: border-box;\n }\n}\n\n@media only screen and (max-width: 320px) {\n #content {\n max-width: 320px;\n box-sizing: border-box;\n }\n}\n\n.walletconnect-modal__base {\n -webkit-font-smoothing: antialiased;\n background: #ffffff;\n border-radius: 24px;\n box-shadow: 0 10px 50px 5px rgba(0, 0, 0, 0.4);\n font-family: ui-rounded, "SF Pro Rounded", "SF Pro Text", medium-content-sans-serif-font,\n -apple-system, BlinkMacSystemFont, ui-sans-serif, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell,\n
typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
typeof Symbol !== "undefined" ? Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator")) : "@@asyncIterator";
function _catch(body, recover) {
try {
var result = body();
} catch (e2) {
return recover(e2);
}
if (result && result.then) {
return result.then(void 0, recover);
}
return result;
}
var WALLETCONNECT_LOGO_SVG_URL = "data:image/svg+xml,%3Csvg height='185' viewBox='0 0 300 185' width='300' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='m61.4385429 36.2562612c48.9112241-47.8881663 128.2119871-47.8881663 177.1232091 0l5.886545 5.7634174c2.445561 2.3944081 2.445561 6.2765112 0 8.6709204l-20.136695 19.715503c-1.222781 1.1972051-3.2053 1.1972051-4.428081 0l-8.100584-7.9311479c-34.121692-33.4079817-89.443886-33.4079817-123.5655788 0l-8.6750562 8.4936051c-1.2227816 1.1972041-3.205301 1.1972041-4.4280806 0l-20.1366949-19.7155031c-2.4455612-2.3944092-2.4455612-6.2765122 0-8.6709204zm218.7677961 40.7737449 17.921697 17.546897c2.445549 2.3943969 2.445563 6.2764769.000031 8.6708899l-80.810171 79.121134c-2.445544 2.394426-6.410582 2.394453-8.85616.000062-.00001-.00001-.000022-.000022-.000032-.000032l-57.354143-56.154572c-.61139-.598602-1.60265-.598602-2.21404 0-.000004.000004-.000007.000008-.000011.000011l-57.3529212 56.154531c-2.4455368 2.394432-6.4105755 2.394472-8.8561612.000087-.0000143-.000014-.0000296-.000028-.0000449-.000044l-80.81241943-79.122185c-2.44556021-2.394408-2.44556021-6.2765115 0-8.6709197l17.92172963-17.5468673c2.4455602-2.3944082 6.4105989-2.3944082 8.8561602 0l57.3549775 56.155357c.6113908.598602 1.602649.598602 2.2140398 0 .0000092-.000009.0000174-.000017.0000265-.000024l57.3521031-56.155333c2.445505-2.3944633 6.410544-2.3945531 8.856161-.0002.000034.0000336.000068.0000673.000101.000101l57.354902 56.155432c.61139.598601 1.60265.598601 2.21404 0l57.353975-56.1543249c2.445561-2.3944092 6.410599-2.3944092 8.85616 0z' fill='%233b99fc'/%3E%3C/svg%3E";
var WALLETCONNECT_HEADER_TEXT = "WalletConnect";
var ANIMATION_DURATION = 300;
var DEFAULT_BUTTON_COLOR = "rgb(64, 153, 255)";
var WALLETCONNECT_WRAPPER_ID = "walletconnect-wrapper";
var WALLETCONNECT_STYLE_ID = "walletconnect-style-sheet";
var WALLETCONNECT_MODAL_ID = "walletconnect-qrcode-modal";
var WALLETCONNECT_CLOSE_BUTTON_ID = "walletconnect-qrcode-close";
var WALLETCONNECT_CTA_TEXT_ID = "walletconnect-qrcode-text";
var WALLETCONNECT_CONNECT_BUTTON_ID = "walletconnect-connect-button";
function Header(props) {
return React.createElement("div", {
className: "walletconnect-modal__header"
}, React.createElement("img", {
src: WALLETCONNECT_LOGO_SVG_URL,
className: "walletconnect-modal__headerLogo"
}), React.createElement("p", null, WALLETCONNECT_HEADER_TEXT), React.createElement("div", {
className: "walletconnect-modal__close__wrapper",
onClick: props.onClose
}, React.createElement("div", {
id: WALLETCONNECT_CLOSE_BUTTON_ID,
className: "walletconnect-modal__close__icon"
}, React.createElement("div", {
className: "walletconnect-modal__close__line1"
}), React.createElement("div", {
className: "walletconnect-modal__close__line2"
}))));
}
function ConnectButton(props) {
return React.createElement("a", {
className: "walletconnect-connect__button",
href: props.href,
id: WALLETCONNECT_CONNECT_BUTTON_ID + "-" + props.name,
onClick: props.onClick,
rel: "noopener noreferrer",
style: {
backgroundColor: props.color
},
target: "_blank"
}, props.name);
}
var CARET_SVG_URL = "data:image/svg+xml,%3Csvg fill='none' height='18' viewBox='0 0 8 18' width='8' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath clip-rule='evenodd' d='m.586301.213898c-.435947.33907-.5144813.967342-.175411 1.403292l4.87831 6.27212c.28087.36111.28087.86677 0 1.22788l-4.878311 6.27211c-.33907.436-.260536 1.0642.175412 1.4033.435949.3391 1.064219.2605 1.403289-.1754l4.87832-6.2721c.84259-1.08336.84259-2.60034 0-3.68367l-4.87832-6.27212c-.33907-.4359474-.96734-.514482-1.403289-.175412z' fill='%233c4252' fill-rule='evenodd'/%3E%3C/svg%3E";
function WalletButton(props) {
var color = props.color;
var href = props.href;
var name = props.name;
var logo = props.logo;
var onClick = props.onClick;
return React.createElement("a", {
className: "walletconnect-modal__base__row",
href,
onClick,
rel: "noopener noreferrer",
target: "_blank"
}, React.createElement("h3", {
className: "walletconnect-modal__base__row__h3"
}, name), React.createElement("div", {
className: "walletconnect-modal__base__row__right"
}, React.createElement("div", {
className: "walletconnect-modal__base__row__right__app-icon",
style: {
background: "url('" + logo + "') " + color,
backgroundSize: "100%"
}
}), React.createElement("img", {
src: CARET_SVG_URL,
className: "walletconnect-modal__base__row__right__caret"
})));
}
function WalletIcon(props) {
var color = props.color;
var href = props.href;
var name = props.name;
var logo = props.logo;
var onClick = props.onClick;
var fontSize = window.innerWidth < 768 ? (name.length > 8 ? 2.5 : 2.7) + "vw" : "inherit";
return React.createElement("a", {
className: "walletconnect-connect__button__icon_anchor",
href,
onClick,
rel: "noopener noreferrer",
target: "_blank"
}, React.createElement("div", {
className: "walletconnect-connect__button__icon",
style: {
background: "url('" + logo + "') " + color,
backgroundSize: "100%"
}
}), React.createElement("div", {
style: {
fontSize
},
className: "walletconnect-connect__button__text"
}, name));
}
var GRID_MIN_COUNT = 5;
var LINKS_PER_PAGE = 12;
function LinkDisplay(props) {
var android = browserUtils.isAndroid();
var ref = React.useState("");
var input = ref[0];
var setInput = ref[1];
var ref$1 = React.useState("");
var filter = ref$1[0];
var setFilter = ref$1[1];
var ref$2 = React.useState(1);
var page = ref$2[0];
var setPage = ref$2[1];
var links = filter ? props.links.filter(function(link) {
return link.name.toLowerCase().includes(filter.toLowerCase());
}) : props.links;
var errorMessage = props.errorMessage;
var grid = filter || links.length > GRID_MIN_COUNT;
var pages = Math.ceil(links.length / LINKS_PER_PAGE);
var range = [(page - 1) * LINKS_PER_PAGE + 1, page * LINKS_PER_PAGE];
var pageLinks = links.length ? links.filter(function(_2, index2) {
return index2 + 1 >= range[0] && index2 + 1 <= range[1];
}) : [];
var hasPaging = !!(!android && pages > 1);
var filterTimeout = void 0;
function handleInput(e2) {
setInput(e2.target.value);
clearTimeout(filterTimeout);
if (e2.target.value) {
filterTimeout = setTimeout(function() {
setFilter(e2.target.value);
setPage(1);
}, 1e3);
} else {
setInput("");
setFilter("");
setPage(1);
}
}
return React.createElement("div", null, React.createElement("p", {
id: WALLETCONNECT_CTA_TEXT_ID,
className: "walletconnect-qrcode__text"
}, android ? props.text.connect_mobile_wallet : props.text.choose_preferred_wallet), !android && React.createElement("input", {
className: "walletconnect-search__input",
placeholder: "Search",
value: input,
onChange: handleInput
}), React.createElement("div", {
className: "walletconnect-connect__buttons__wrapper" + (android ? "__android" : grid && links.length ? "__wrap" : "")
}, !android ? pageLinks.length ? pageLinks.map(function(entry) {
var color = entry.color;
var name = entry.name;
var shortName = entry.shortName;
var logo = entry.logo;
var href = browserUtils.formatIOSMobile(props.uri, entry);
var handleClickIOS = React.useCallback(function() {
browserUtils.saveMobileLinkInfo({
name,
href
});
}, [pageLinks]);
return !grid ? React.createElement(WalletButton, {
color,
href,
name,
logo,
onClick: handleClickIOS
}) : React.createElement(WalletIcon, {
color,
href,
name: shortName || name,
logo,
onClick: handleClickIOS
});
}) : React.createElement(React.Fragment, null, React.createElement("p", null, errorMessage.length ? props.errorMessage : !!props.links.length && !links.length ? props.text.no_wallets_found : props.text.loading)) : React.createElement(ConnectButton, {
name: props.text.connect,
color: DEFAULT_BUTTON_COLOR,
href: props.uri,
onClick: React.useCallback(function() {
browserUtils.saveMobileLinkInfo({
name: "Unknown",
href: props.uri
});
}, [])
})), hasPaging && React.createElement("div", {
className: "walletconnect-modal__footer"
}, Array(pages).fill(0).map(function(_2, index2) {
var pageNumber = index2 + 1;
var selected = page === pageNumber;
return React.createElement("a", {
style: {
margin: "auto 10px",
fontWeight: selected ? "bold" : "normal"
},
onClick: function() {
return setPage(pageNumber);
}
}, pageNumber);
})));
}
function Notification(props) {
var show = !!props.message.trim();
return React.createElement("div", {
className: "walletconnect-qrcode__notification" + (show ? " notification__show" : "")
}, props.message);
}
var formatQRCodeImage = function(data) {
try {
var result = "";
return Promise.resolve(QRCode.toString(data, {
margin: 0,
type: "svg"
})).then(function(dataString) {
if (typeof dataString === "string") {
result = dataString.replace("<svg", '<svg class="walletconnect-qrcode__image"');
}
return result;
});
} catch (e2) {
return Promise.reject(e2);
}
};
function QRCodeDisplay(props) {
var ref = React.useState("");
var notification = ref[0];
var setNotification = ref[1];
var ref$1 = React.useState("");
var svg = ref$1[0];
var setSvg = ref$1[1];
React.useEffect(function() {
try {
return Promise.resolve(formatQRCodeImage(props.uri)).then(function(_formatQRCodeImage) {
setSvg(_formatQRCodeImage);
});
} catch (e2) {
Promise.reject(e2);
}
}, []);
var copyToClipboard2 = function() {
var success = copy2(props.uri);
if (success) {
setNotification(props.text.copied_to_clipboard);
setInterval(function() {
return setNotification("");
}, 1200);
} else {
setNotification("Error");
setInterval(function() {
return setNotification("");
}, 1200);
}
};
return React.createElement("div", null, React.createElement("p", {
id: WALLETCONNECT_CTA_TEXT_ID,
className: "walletconnect-qrcode__text"
}, props.text.scan_qrcode_with_wallet), React.createElement("div", {
dangerouslySetInnerHTML: {
__html: svg
}
}), React.createElement("div", {
className: "walletconnect-modal__footer"
}, React.createElement("a", {
onClick: copyToClipboard2
}, props.text.copy_to_clipboard)), React.createElement(Notification, {
message: notification
}));
}
function Modal(props) {
var android = browserUtils.isAndroid();
var mobile = browserUtils.isMobile();
var whitelist = mobile ? props.qrcodeModalOptions && props.qrcodeModalOptions.mobileLinks ? props.qrcodeModalOptions.mobileLinks : void 0 : props.qrcodeModalOptions && props.qrcodeModalOptions.desktopLinks ? props.qrcodeModalOptions.desktopLinks : void 0;
var ref = React.useState(false);
var loading = ref[0];
var setLoading = ref[1];
var ref$1 = React.useState(false);
var fetched = ref$1[0];
var setFetched = ref$1[1];
var ref$2 = React.useState(!mobile);
var displayQRCode = ref$2[0];
var setDisplayQRCode = ref$2[1];
var displayProps = {
mobile,
text: props.text,
uri: props.uri,
qrcodeModalOptions: props.qrcodeModalOptions
};
var ref$3 = React.useState("");
var singleLinkHref = ref$3[0];
var setSingleLinkHref = ref$3[1];
var ref$4 = React.useState(false);
var hasSingleLink = ref$4[0];
var setHasSingleLink = ref$4[1];
var ref$5 = React.useState([]);
var links = ref$5[0];
var setLinks = ref$5[1];
var ref$6 = React.useState("");
var errorMessage = ref$6[0];
var setErrorMessage = ref$6[1];
var getLinksIfNeeded = function() {
if (fetched || loading || whitelist && !whitelist.length || links.length > 0) {
return;
}
React.useEffect(function() {
var initLinks = function() {
try {
if (android) {
return Promise.resolve();
}
setLoading(true);
var _temp = _catch(function() {
var url = props.qrcodeModalOptions && props.qrcodeModalOptions.registryUrl ? props.qrcodeModalOptions.registryUrl : browserUtils.getWalletRegistryUrl();
return Promise.resolve(fetch(url)).then(function(registryResponse) {
return Promise.resolve(registryResponse.json()).then(function(_registryResponse$jso) {
var registry = _registryResponse$jso.listings;
var platform = mobile ? "mobile" : "desktop";
var _links = browserUtils.getMobileLinkRegistry(browserUtils.formatMobileRegistry(registry, platform), whitelist);
setLoading(false);
setFetched(true);
setErrorMessage(!_links.length ? props.text.no_supported_wallets : "");
setLinks(_links);
var hasSingleLink2 = _links.length === 1;
if (hasSingleLink2) {
setSingleLinkHref(browserUtils.formatIOSMobile(props.uri, _links[0]));
setDisplayQRCode(true);
}
setHasSingleLink(hasSingleLink2);
});
});
}, function(e2) {
setLoading(false);
setFetched(true);
setErrorMessage(props.text.something_went_wrong);
console.error(e2);
});
return Promise.resolve(_temp && _temp.then ? _temp.then(function() {
}) : void 0);
} catch (e2) {
return Promise.reject(e2);
}
};
initLinks();
});
};
getLinksIfNeeded();
var rightSelected = mobile ? displayQRCode : !displayQRCode;
return React.createElement("div", {
id: WALLETCONNECT_MODAL_ID,
className: "walletconnect-qrcode__base animated fadeIn"
}, React.createElement("div", {
className: "walletconnect-modal__base"
}, React.createElement(Header, {
onClose: props.onClose
}), hasSingleLink && displayQRCode ? React.createElement("div", {
className: "walletconnect-modal__single_wallet"
}, React.createElement("a", {
onClick: function() {
return browserUtils.saveMobileLinkInfo({
name: links[0].name,
href: singleLinkHref
});
},
href: singleLinkHref,
rel: "noopener noreferrer",
target: "_blank"
}, props.text.connect_with + " " + (hasSingleLink ? links[0].name : "") + " ›")) : android || loading || !loading && links.length ? React.createElement("div", {
className: "walletconnect-modal__mobile__toggle" + (rightSelected ? " right__selected" : "")
}, React.createElement("div", {
className: "walletconnect-modal__mobile__toggle_selector"
}), mobile ? React.createElement(React.Fragment, null, React.createElement("a", {
onClick: function() {
return setDisplayQRCode(false), getLinksIfNeeded();
}
}, props.text.mobile), React.createElement("a", {
onClick: function() {
return setDisplayQRCode(true);
}
}, props.text.qrcode)) : React.createElement(React.Fragment, null, React.createElement("a", {
onClick: function() {
return setDisplayQRCode(true);
}
}, props.text.qrcode), React.createElement("a", {
onClick: function() {
return setDisplayQRCode(false), getLinksIfNeeded();
}
}, props.text.desktop))) : null, React.createElement("div", null, displayQRCode || !android && !loading && !links.length ? React.createElement(QRCodeDisplay, Object.assign({}, displayProps)) : React.createElement(LinkDisplay, Object.assign(
{},
displayProps,
{
links,
errorMessage
}
)))));
}
var de = {
choose_preferred_wallet: "Wähle bevorzugte Wallet",
connect_mobile_wallet: "Verbinde mit Mobile Wallet",
scan_qrcode_with_wallet: "Scanne den QR-code mit einer WalletConnect kompatiblen Wallet",
connect: "Verbinden",
qrcode: "QR-Code",
mobile: "Mobile",
desktop: "Desktop",
copy_to_clipboard: "In die Zwischenablage kopieren",
copied_to_clipboard: "In die Zwischenablage kopiert!",
connect_with: "Verbinden mit Hilfe von",
loading: "Laden...",
something_went_wrong: "Etwas ist schief gelaufen",
no_supported_wallets: "Es gibt noch keine unterstützten Wallet",
no_wallets_found: "keine Wallet gefunden"
};
var en = {
choose_preferred_wallet: "Choose your preferred wallet",
connect_mobile_wallet: "Connect to Mobile Wallet",
scan_qrcode_with_wallet: "Scan QR code with a WalletConnect-compatible wallet",
connect: "Connect",
qrcode: "QR Code",
mobile: "Mobile",
desktop: "Desktop",
copy_to_clipboard: "Copy to clipboard",
copied_to_clipboard: "Copied to clipboard!",
connect_with: "Connect with",
loading: "Loading...",
something_went_wrong: "Something went wrong",
no_supported_wallets: "There are no supported wallets yet",
no_wallets_found: "No wallets found"
};
var es = {
choose_preferred_wallet: "Elige tu billetera preferida",
connect_mobile_wallet: "Conectar a billetera móvil",
scan_qrcode_with_wallet: "Escanea el código QR con una billetera compatible con WalletConnect",
connect: "Conectar",
qrcode: "Código QR",
mobile: "Móvil",
desktop: "Desktop",
copy_to_clipboard: "Copiar",
copied_to_clipboard: "Copiado!",
connect_with: "Conectar mediante",
loading: "Cargando...",
something_went_wrong: "Algo salió mal",
no_supported_wallets: "Todavía no hay billeteras compatibles",
no_wallets_found: "No se encontraron billeteras"
};
var fr = {
choose_preferred_wallet: "Choisissez votre portefeuille préféré",
connect_mobile_wallet: "Se connecter au portefeuille mobile",
scan_qrcode_with_wallet: "Scannez le QR code avec un portefeuille compatible WalletConnect",
connect: "Se connecter",
qrcode: "QR Code",
mobile: "Mobile",
desktop: "Desktop",
copy_to_clipboard: "Copier",
copied_to_clipboard: "Copié!",
connect_with: "Connectez-vous à l'aide de",
loading: "Chargement...",
something_went_wrong: "Quelque chose a mal tourné",
no_supported_wallets: "Il n'y a pas encore de portefeuilles pris en charge",
no_wallets_found: "Aucun portefeuille trouvé"
};
var ko = {
choose_preferred_wallet: "원하는 지갑을 선택하세요",
connect_mobile_wallet: "모바일 지갑과 연결",
scan_qrcode_with_wallet: "WalletConnect 지원 지갑에서 QR코드를 스캔하세요",
connect: "연결",
qrcode: "QR 코드",
mobile: "모바일",
desktop: "데스크탑",
copy_to_clipboard: "클립보드에 복사",
copied_to_clipboard: "클립보드에 복사되었습니다!",
connect_with: "와 연결하다",
loading: "로드 중...",
something_went_wrong: "문제가 발생했습니다.",
no_supported_wallets: "아직 지원되는 지갑이 없습니다",
no_wallets_found: "지갑을 찾을 수 없습니다"
};
var pt = {
choose_preferred_wallet: "Escolha sua carteira preferida",
connect_mobile_wallet: "Conectar-se à carteira móvel",
scan_qrcode_with_wallet: "Ler o código QR com uma carteira compatível com WalletConnect",
connect: "Conectar",
qrcode: "Código QR",
mobile: "Móvel",
desktop: "Desktop",
copy_to_clipboard: "Copiar",
copied_to_clipboard: "Copiado!",
connect_with: "Ligar por meio de",
loading: "Carregamento...",
something_went_wrong: "Algo correu mal",
no_supported_wallets: "Ainda não há carteiras suportadas",
no_wallets_found: "Nenhuma carteira encontrada"
};
var zh = {
choose_preferred_wallet: "选择你的钱包",
connect_mobile_wallet: "连接至移动端钱包",
scan_qrcode_with_wallet: "使用兼容 WalletConnect 的钱包扫描二维码",
connect: "连接",
qrcode: "二维码",
mobile: "移动",
desktop: "桌面",
copy_to_clipboard: "复制到剪贴板",
copied_to_clipboard: "复制到剪贴板成功！",
connect_with: "通过以下方式连接",
loading: "正在加载...",
something_went_wrong: "出了问题",
no_supported_wallets: "目前还没有支持的钱包",
no_wallets_found: "没有找到钱包"
};
var fa = {
choose_preferred_wallet: "کیف پول مورد نظر خود را انتخاب کنید",
connect_mobile_wallet: "به کیف پول موبایل وصل شوید",
scan_qrcode_with_wallet: "کد QR را با یک کیف پول سازگار با WalletConnect اسکن کنید",
connect: "اتصال",
qrcode: "کد QR",
mobile: "سیار",
desktop: "دسکتاپ",
copy_to_clipboard: "کپی به کلیپ بورد",
copied_to_clipboard: "در کلیپ بورد کپی شد!",
connect_with: "ارتباط با",
loading: "...بارگذاری",
something_went_wrong: "مشکلی پیش آمد",
no_supported_wallets: "هنوز هیچ کیف پول پشتیبانی شده ای وجود ندارد",
no_wallets_found: "هیچ کیف پولی پیدا نشد"
};
var languages = {
de,
en,
es,
fr,
ko,
pt,
zh,
fa
};
function injectStyleSheet() {
var doc = browserUtils.getDocumentOrThrow();
var prev = doc.getElementById(WALLETCONNECT_STYLE_ID);
if (prev) {
doc.head.removeChild(prev);
}
var style = doc.createElement("style");
style.setAttribute("id", WALLETCONNECT_STYLE_ID);
style.innerText = WALLETCONNECT_STYLE_SHEET;
doc.head.appendChild(style);
}
function renderWrapper() {
var doc = browserUtils.getDocumentOrThrow();
var wrapper = doc.createElement("div");
wrapper.setAttribute("id", WALLETCONNECT_WRAPPER_ID);
doc.body.appendChild(wrapper);
return wrapper;
}
function triggerCloseAnimation() {
var doc = browserUtils.getDocumentOrThrow();
var modal = doc.getElementById(WALLETCONNECT_MODAL_ID);
if (modal) {
modal.className = modal.className.replace("fadeIn", "fadeOut");
setTimeout(function() {
var wrapper = doc.getElementById(WALLETCONNECT_WRAPPER_ID);
if (wrapper) {
doc.body.removeChild(wrapper);
}
}, ANIMATION_DURATION);
}
}
function getWrappedCallback(cb) {
return function() {
triggerCloseAnimation();
if (cb) {
cb();
}
};
}
function getText() {
var lang = browserUtils.getNavigatorOrThrow().language.split("-")[0] || "en";
return languages[lang] || languages["en"];
}
function open$1(uri, cb, qrcodeModalOptions) {
injectStyleSheet();
var wrapper = renderWrapper();
React.render(React.createElement(Modal, {
text: getText(),
uri,
onClose: getWrappedCallback(cb),
qrcodeModalOptions
}), wrapper);
}
function close$1() {
triggerCloseAnimation();
}
var isNode = function() {
return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
};
function open$2(uri, cb, qrcodeModalOptions) {
console.log(uri);
if (isNode()) {
open(uri);
} else {
open$1(uri, cb, qrcodeModalOptions);
}
}
function close$2() {
if (isNode())
;
else {
close$1();
}
}
var index = {
open: open$2,
close: close$2
};
var cjs = index;
class SignerConnection extends IJsonRpcConnection {
constructor(opts) {
super();
this.events = new EventEmitter();
this.accounts = [];
this.chainId = 1;
this.pending = false;
this.bridge = "https://bridge.walletconnect.org";
this.qrcode = true;
this.qrcodeModalOptions = void 0;
this.opts = opts;
this.chainId = (opts === null || opts === void 0 ? void 0 : opts.chainId) || this.chainId;
this.wc = this.register(opts);
}
get connected() {
return typeof this.wc !== "undefined" && this.wc.connected;
}
get connecting() {
return this.pending;
}
get connector() {
this.wc = this.register(this.opts);
return this.wc;
}
on(event, listener) {
this.events.on(event, listener);
}
once(event, listener) {
this.events.once(event, listener);
}
off(event, listener) {
this.events.off(event, listener);
}
removeListener(event, listener) {
this.events.removeListener(event, listener);
}
async open(chainId) {
if (this.connected) {
this.onOpen();
return;
}
return new Promise((resolve, reject) => {
this.on("error", (err) => {
reject(err);
});
this.on("open", () => {
resolve();
});
this.create(chainId);
});
}
async close() {
if (typeof this.wc === "undefined")
return;
if (this.wc.connected) {
this.wc.killSession();
}
this.onClose();
}
async send(payload) {
this.wc = this.register(this.opts);
if (!this.connected)
await this.open();
this.sendPayload(payload).then((res) => this.events.emit("payload", res)).catch((e2) => this.events.emit("payload", formatJsonRpcError(payload.id, e2.message)));
}
register(opts) {
if (this.wc)
return this.wc;
this.opts = opts || this.opts;
this.bridge = (opts === null || opts === void 0 ? void 0 : opts.connector) ? opts.connector.bridge : (opts === null || opts === void 0 ? void 0 : opts.bridge) || "https://bridge.walletconnect.org";
this.qrcode = typeof (opts === null || opts === void 0 ? void 0 : opts.qrcode) === "undefined" || opts.qrcode !== false;
this.chainId = typeof (opts === null || opts === void 0 ? void 0 : opts.chainId) !== "undefined" ? opts.chainId : this.chainId;
this.qrcodeModalOptions = opts === null || opts === void 0 ? void 0 : opts.qrcodeModalOptions;
const connectorOpts = {
bridge: this.bridge,
qrcodeModal: this.qrcode ? cjs : void 0,
qrcodeModalOptions: this.qrcodeModalOptions,
storageId: opts === null || opts === void 0 ? void 0 : opts.storageId,
signingMethods: opts === null || opts === void 0 ? void 0 : opts.signingMethods,
clientMeta: opts === null || opts === void 0 ? void 0 : opts.clientMeta
};
this.wc = typeof (opts === null || opts === void 0 ? void 0 : opts.connector) !== "undefined" ? opts.connector : new WalletConnect(connectorOpts);
if (typeof this.wc === "undefined") {
throw new Error("Failed to register WalletConnect connector");
}
if (this.wc.accounts.length) {
this.accounts = this.wc.accounts;
}
if (this.wc.chainId) {
this.chainId = this.wc.chainId;
}
this.registerConnectorEvents();
return this.wc;
}
onOpen(wc) {
this.pending = false;
if (wc) {
this.wc = wc;
}
this.events.emit("open");
}
onClose() {
this.pending = false;
if (this.wc) {
this.wc = void 0;
}
this.events.emit("close");
}
onError(payload, message = "Failed or Rejected Request", code = -32e3, data) {
const errorPayload = {
id: payload.id,
jsonrpc: payload.jsonrpc,
error: { code, message }
};
if (typeof data !== "undefined") {
errorPayload.error.data = data;
}
this.events.emit("payload", errorPayload);
return errorPayload;
}
create(chainId) {
this.wc = this.register(this.opts);
this.chainId = chainId || this.chainId;
if (this.connected || this.pending)
return;
this.pending = true;
this.registerConnectorEvents();
this.wc.createSession({ chainId: this.chainId }).then(() => this.events.emit("created")).catch((e2) => this.events.emit("error", e2));
}
registerConnectorEvents() {
this.wc = this.register(this.opts);
this.wc.on("connect", (err) => {
var _a, _b;
if (err) {
this.events.emit("error", err);
return;
}
this.accounts = ((_a = this.wc) === null || _a === void 0 ? void 0 : _a.accounts) || [];
this.chainId = ((_b = this.wc) === null || _b === void 0 ? void 0 : _b.chainId) || this.chainId;
this.onOpen();
});
this.wc.on("disconnect", (err) => {
if (err) {
this.events.emit("error", err);
return;
}
this.onClose();
});
this.wc.on("modal_closed", () => {
this.events.emit("error", new Error("User closed modal"));
});
this.wc.on("session_update", (error, payload) => {
const { accounts, chainId } = payload.params[0];
if (!this.accounts || accounts && this.accounts !== accounts) {
this.accounts = accounts;
this.events.emit("accountsChanged", accounts);
}
if (!this.chainId || chainId && this.chainId !== chainId) {
this.chainId = chainId;
this.events.emit("chainChanged", chainId);
}
});
}
async sendPayload(payload) {
this.wc = this.register(this.opts);
try {
const response = await this.wc.unsafeSend(payload);
return this.sanitizeResponse(response);
} catch (error) {
return this.onError(payload, error.message);
}
}
sanitizeResponse(response) {
return typeof response.error !== "undefined" && typeof response.error.code === "undefined" ? formatJsonRpcError(response.id, response.error.message, response.error.data) : response;
}
}
class WalletConnectProvider {
constructor(opts) {
this.events = new EventEmitter();
this.rpc = { infuraId: opts === null || opts === void 0 ? void 0 : opts.infuraId, custom: opts === null || opts === void 0 ? void 0 : opts.rpc };
this.signer = new JsonRpcProvider(new SignerConnection(opts));
const chainId = this.signer.connection.chainId || (opts === null || opts === void 0 ? void 0 : opts.chainId) || 1;
this.http = this.setHttpProvider(chainId);
this.registerEventListeners();
}
get connected() {
return this.signer.connection.connected;
}
get connector() {
return this.signer.connection.connector;
}
get accounts() {
return this.signer.connection.accounts;
}
get chainId() {
return this.signer.connection.chainId;
}
get rpcUrl() {
var _a;
return ((_a = this.http) === null || _a === void 0 ? void 0 : _a.connection).url || "";
}
async request(args) {
switch (args.method) {
case "eth_requestAccounts":
await this.connect();
return this.signer.connection.accounts;
case "eth_accounts":
return this.signer.connection.accounts;
case "eth_chainId":
return this.signer.connection.chainId;
}
if (signingMethods.includes(args.method)) {
return this.signer.request(args);
}
if (typeof this.http === "undefined") {
throw new Error(`Cannot request JSON-RPC method (${args.method}) without provided rpc url`);
}
return this.http.request(args);
}
sendAsync(args, callback) {
this.request(args).then((response) => callback(null, response)).catch((error) => callback(error, void 0));
}
async enable() {
const accounts = await this.request({ method: "eth_requestAccounts" });
return accounts;
}
async connect() {
if (!this.signer.connection.connected) {
await this.signer.connect();
}
}
async disconnect() {
if (this.signer.connection.connected) {
await this.signer.disconnect();
}
}
on(event, listener) {
this.events.on(event, listener);
}
once(event, listener) {
this.events.once(event, listener);
}
removeListener(event, listener) {
this.events.removeListener(event, listener);
}
off(event, listener) {
this.events.off(event, listener);
}
get isWalletConnect() {
return true;
}
registerEventListeners() {
this.signer.connection.on("accountsChanged", (accounts) => {
this.events.emit("accountsChanged", accounts);
});
this.signer.connection.on("chainChanged", (chainId) => {
this.http = this.setHttpProvider(chainId);
this.events.emit("chainChanged", chainId);
});
this.signer.on("disconnect", () => {
this.events.emit("disconnect");
});
}
setHttpProvider(chainId) {
const rpcUrl = getRpcUrl(chainId, this.rpc);
if (typeof rpcUrl === "undefined")
return void 0;
const http = new JsonRpcProvider(new HttpConnection(rpcUrl));
return http;
}
}
export {
WalletConnectProvider as default
};
Reference in a new issue Copy permalink